@neocompose/cli 0.22.6 → 0.23.0

package/CHANGELOG.md

@@ -1,5 +1,48 @@
 # Changelog
 
+## [0.23.0] - 2026-08-05
+
+### Added
+
+- Member defaults may be operator expressions — arithmetic over statics,
+  coalesce, indexing, type tests, string interpolation, and negation of a
+  non-literal. They are stored as computed initializers evaluated during
+  construction, exactly like call defaults, instead of failing with
+  "Expression binary is not a persisted default." Positions that store no
+  rows keep requiring literals and now say so precisely: dictionary keys,
+  Vector/Color components, and an `@id` written on part of an unparenthesized
+  computed entry (parenthesize the expression so the annotation names the
+  row).
+
+### Fixed
+
+- Function members lower with the contract's value-less `required: false`
+  shape, so a push that adds a `.neo` function passes prospective validation,
+  and stored functions stop generating phantom `required` updates on every
+  push. Compiled bodies that read static members validate through the
+  previously missing static-member pointer guard.
+- Push preparation reads the prospective document with pending enum-option
+  ids admitted and source-authored localized texts completed through the
+  server's own create envelope, so a push that creates an enum, adds an
+  option, or authors localized text no longer fails initializer
+  materialization or prospective animation validation. Committed-document
+  reads keep their exact strictness.
+- Stored function bodies re-emit whole. A body opening with a nested block
+  (`switch`, `if`) was truncated to that block — leaking trailing statements
+  to class scope — and a body that was exactly one block silently lost its
+  guard on pull. An authored empty body re-emits as `{ }` instead of mutating
+  into a `native` signature.
+
+## [0.22.7] - 2026-08-05
+
+### Fixed
+
+- Pull and reset cache canonical required-constructor calls reconstructed from
+  legacy materialized rows that predate durable constructor arguments.
+- A pull followed by status or push remains a semantic no-op for projected
+  animation track and generic segment-frame rows, while later constructor edits
+  are still detected normally.
+
 ## [0.22.6] - 2026-08-05
 
 ### Fixed

package/dist/neo.mjs

@@ -35135,6 +35135,12 @@ function isNSPointerVariable(value) {
   const v = value;
   return v?.type === "variable" /* variable */ && typeof v?.variableId === "string";
 }
+function isNSPointerStaticMember(value) {
+  const v = value;
+  if (v?.type !== "staticMember" /* staticMember */) return false;
+  if (typeof v.memberId !== "string") return false;
+  return v.memberId.length > 0;
+}
 function isNSPointerValue(value) {
   const v = value;
   return v?.type === "value" /* value */ && isNSValue(v?.value);
@@ -35260,7 +35266,7 @@ function isNSPointerFunctionErrorCheck(value) {
   return isNSFunctionErrorCheckMode(v.mode);
 }
 function isNSPointer(value) {
-  return isNSPointerReference(value) || isNSPointerVariable(value) || isNSPointerValue(value) || isNSPointerOperation(value) || isNSPointerFunction(value) || isNSPointerKeyOf(value) || isNSPointerListLiteral(value) || isNSPointerDictLiteral(value) || isNSPointerForceUnwrap(value) || isNSPointerIsCheck(value) || isNSPointerCallGetter(value) || isNSPointerCoalesce(value) || isNSPointerToBool(value) || isNSPointerStringify(value) || isNSPointerCallFunction(value) || isNSPointerCallDelegate(value) || isNSPointerFunctionErrorCheck(value);
+  return isNSPointerReference(value) || isNSPointerVariable(value) || isNSPointerStaticMember(value) || isNSPointerValue(value) || isNSPointerOperation(value) || isNSPointerFunction(value) || isNSPointerKeyOf(value) || isNSPointerListLiteral(value) || isNSPointerDictLiteral(value) || isNSPointerForceUnwrap(value) || isNSPointerIsCheck(value) || isNSPointerCallGetter(value) || isNSPointerCoalesce(value) || isNSPointerToBool(value) || isNSPointerStringify(value) || isNSPointerCallFunction(value) || isNSPointerCallDelegate(value) || isNSPointerFunctionErrorCheck(value);
 }
 function isNSPointers(value) {
   return Array.isArray(value) && value.every(isNSPointer);
@@ -40714,20 +40720,25 @@ function isValidEnumOptionId(id2) {
   if (typeof id2 !== "string" || id2.length === 0) return false;
   return OPTION_ID_REGEX.test(withoutSystemRecordIdPrefix(id2));
 }
+function isProspectiveEnumOptionId(id2) {
+  if (typeof id2 !== "string" || id2.length === 0) return false;
+  if (isPendingId(id2)) return true;
+  return isValidEnumOptionId(id2);
+}
 function isValidEnumOptionName(name) {
   return isValidSchemaAuthoredIdentifier(name);
 }
-function isEnumOption(value) {
+function isEnumOptionWithIds(value, isOptionId) {
   const v = value;
-  return !!v && isValidDocsText(v.docsText) && typeof v.text === "string" && typeof v.id === "string" && isValidEnumOptionId(v.id) && typeof v.name === "string" && isValidEnumOptionName(v.name);
+  return !!v && isValidDocsText(v.docsText) && typeof v.text === "string" && typeof v.id === "string" && isOptionId(v.id) && typeof v.name === "string" && isValidEnumOptionName(v.name);
 }
-function isEnumOptionsRecord(value) {
+function isEnumOptionsRecordWithIds(value, isOptionId) {
   if (value === null || value === void 0) return false;
   if (typeof value !== "object") return false;
   if (Array.isArray(value)) return false;
   for (const [k, v] of Object.entries(value)) {
-    if (!isValidEnumOptionId(k)) return false;
-    if (!isEnumOption(v)) return false;
+    if (!isOptionId(k)) return false;
+    if (!isEnumOptionWithIds(v, isOptionId)) return false;
     if (v.id !== k) return false;
   }
   return true;
@@ -40737,12 +40748,12 @@ function isOptionalOptionKeyOrder(value) {
   if (!Array.isArray(value)) return false;
   return value.every((key) => typeof key === "string");
 }
-function isEnumBase(value) {
+function isEnumBaseWithIds(value, isOptionId) {
   const v = value;
   if (!v) return false;
   if (typeof v.name !== "string") return false;
   if (!isValidDocsText(v.docsText)) return false;
-  if (!isEnumOptionsRecord(v.options)) return false;
+  if (!isEnumOptionsRecordWithIds(v.options, isOptionId)) return false;
   if (!isOptionalOptionKeyOrder(v.optionKeyOrder)) return false;
   if (v.system !== void 0 && v.system !== null) {
     return isSystemMetadata(v.system);
@@ -40767,17 +40778,24 @@ function getEnumOptionKeyOrder(enumDef) {
   }
   return result;
 }
-function isEnumProps(value) {
+function isEnumPropsWithIds(value, isOptionId) {
   const v = value;
-  return isEnumBase(value) && isWithId(value) && typeof v?.projectId === "string" && isEpochMillis(v?.createdAt) && isEpochMillis(v?.updatedAt);
+  return isEnumBaseWithIds(value, isOptionId) && isWithId(value) && typeof v?.projectId === "string" && isEpochMillis(v?.createdAt) && isEpochMillis(v?.updatedAt);
+}
+function isEnumProps(value) {
+  return isEnumPropsWithIds(value, isValidEnumOptionId);
 }
 function isEnum(value) {
   return isEnumProps(value);
 }
+function isProspectiveEnum(value) {
+  return isEnumPropsWithIds(value, isProspectiveEnumOptionId);
+}
 var OPTION_ID_REGEX;
 var init_enum_types = __esm({
   "../src/models/enum/enum-types.ts"() {
     "use strict";
+    init_src();
     init_core();
     init_schema_identifiers();
     init_system_record_id();
@@ -43144,12 +43162,10 @@ ${prefix}${renderType(context, member.returnType)} ${member.name}${body}`;
       (argument2) => `${renderType(context, argument2.type)} ${argument2.name}`
     ).join(", ")})`;
     const tracked = member.kind === "scriptFunction" ? member.script?.sourceText ?? uiFunctionSource(context, member) : null;
-    const body = tracked ? extractBody(tracked) ?? `{
-${indentNeoSourceNonEmptyLines(tracked.trim(), 2)}
-}` : null;
+    const body = tracked === null ? null : emitFunctionBody(tracked);
     const abstractContract = member.modifier === "abstract" || member.modifier === "abstractOverride";
     return `${annotations.join("\n")}
-${body ? `${signature} ${body}` : abstractContract ? `${signature};` : `native ${signature};`}`;
+${body !== null ? `${signature} ${body}` : abstractContract ? `${signature};` : `native ${signature};`}`;
   }
   const type = renderMemberType(context, member, enclosingClassId);
   const initializer = initDefaultSource(member) ?? (member.isStatic ? context.staticInitializers.get(member.id) : void 0) ?? context.defaultInitializers.get(member.id) ?? renderDefault(context, member);
@@ -43951,10 +43967,12 @@ function systemAnnotation2(system) {
   ];
   return `@system(${args.join(", ")})`;
 }
-function extractBody(source) {
-  const start = source.indexOf("{");
-  const end = source.lastIndexOf("}");
-  return start >= 0 && end > start ? source.slice(start, end + 1).trim() : null;
+function emitFunctionBody(sourceText) {
+  const code = sourceText.trim();
+  if (code.length === 0) return "{\n}";
+  return `{
+${indentNeoSourceNonEmptyLines(code, 2)}
+}`;
 }
 function id(value) {
   return `@id(${quote(value)})
@@ -48226,6 +48244,7 @@ function initializerRequiresEvaluation(index, expression, targetClassName, runti
     return true;
   }
   if (expression.kind === "call") return !isLiteralCall(expression);
+  if (isEvaluatedOnlyExpression(expression)) return true;
   if (expression.kind !== "new") return false;
   const className = expression.className ?? targetClassName;
   if (!declaresConstructors(index, className)) return false;
@@ -48301,6 +48320,24 @@ function expressionReadsRuntimeIdentifier(expression, runtimeIdentifiers) {
       return false;
   }
 }
+function isEvaluatedOnlyExpression(expression) {
+  switch (expression.kind) {
+    case "annotated":
+      return isEvaluatedOnlyExpression(expression.expression);
+    case "binary":
+    case "coalesce":
+    case "index":
+    case "is":
+    case "force":
+    case "litInterp":
+      return true;
+    case "unary":
+      if (expression.op !== "-") return true;
+      return isEvaluatedOnlyExpression(expression.operand);
+    default:
+      return false;
+  }
+}
 function isLiteralCall(expression) {
   if (expression.callee.kind === "ident" && expression.callee.name === "Reference") {
     return true;
@@ -49232,10 +49269,13 @@ function memberCommon(context, ownerClass, declaration, id2, owner, base) {
     accessModifier: owner.kind === "classMember" ? effectiveSourceAccessModifier(declaration.modifiers, "class") : "public",
     modifier: memberModifier3(declaration.modifiers, base?.modifier),
     locked: hasAnnotation2(declaration.annotations, "locked"),
-    // Every declaration kind carries a type, and its nullability is the whole
-    // of what `required` means. Properties and getters used to fall back to
-    // the pulled value, which left a fresh workspace calling them optional.
-    required: !declaration.type.nullable,
+    // Every value-bearing declaration carries a type, and its nullability is
+    // the whole of what `required` means. Properties and getters used to fall
+    // back to the pulled value, which left a fresh workspace calling them
+    // optional. A callable owns no value, so `required` is fixed `false`
+    // (nsfunction-member.md §1.2, function-member.md) and the declared
+    // nullability travels in `returnTypeInfo.required` instead.
+    required: declaration.kind === "function" ? false : !declaration.type.nullable,
     defaultValue: null,
     overrideOf: inheritedId,
     system: systemMetadata(declaration.annotations),
@@ -49955,15 +49995,7 @@ function lowerDefault(context, initializer, type, ownerClass, base, memberId, st
     return base?.defaultValue && "serverValueId" in base.defaultValue ? base.defaultValue : null;
   }
   const expression = parseExpression(initializer);
-  if (!isStoredDelegateLiteral(type, expression) && initializerRequiresEvaluation(
-    context.declaredConstructors,
-    expression,
-    type.name,
-    requiredConstructorParameterNames(
-      context.declaredConstructors,
-      ownerClass.name
-    )
-  )) {
+  if (positionRequiresEvaluation(context, expression, type, ownerClass)) {
     return { init: { code: normalizeInitializerSource(initializer) } };
   }
   if (context.rowBackedDefaultMemberIds.has(memberId) && base?.defaultValue && !("serverValueId" in base.defaultValue)) {
@@ -50029,15 +50061,7 @@ function lowerExpressionValue(context, expression, declaredExpected, ownerClass,
     declaredExpected,
     genericEnvironment
   );
-  if (!isStoredDelegateLiteral(expected, expression) && initializerRequiresEvaluation(
-    context.declaredConstructors,
-    expression,
-    expected.name,
-    requiredConstructorParameterNames(
-      context.declaredConstructors,
-      ownerClass.name
-    )
-  )) {
+  if (positionRequiresEvaluation(context, expression, expected, ownerClass)) {
     return null;
   }
   if (expression.kind === "annotated") {
@@ -50116,10 +50140,20 @@ function lowerExpressionValue(context, expression, declaredExpected, ownerClass,
       const valueType = expected.arguments[1] ?? expected;
       const value = {};
       for (const entry of expression.entries) {
+        if (positionRequiresEvaluation(
+          context,
+          entry.key,
+          DICTIONARY_KEY_TYPE,
+          ownerClass
+        )) {
+          throw new Error(
+            `Dictionary key at ${path} is a computed expression. Dictionary keys must be string literals.`
+          );
+        }
         const key = lowerExpressionValue(
           context,
           entry.key,
-          { name: "string", nullable: false, arguments: [] },
+          DICTIONARY_KEY_TYPE,
           ownerClass,
           path,
           genericEnvironment,
@@ -50293,6 +50327,18 @@ function lowerExpressionValue(context, expression, declaredExpected, ownerClass,
       );
   }
 }
+function positionRequiresEvaluation(context, expression, expected, ownerClass) {
+  if (isStoredDelegateLiteral(expected, expression)) return false;
+  return initializerRequiresEvaluation(
+    context.declaredConstructors,
+    expression,
+    expected.name,
+    requiredConstructorParameterNames(
+      context.declaredConstructors,
+      ownerClass.name
+    )
+  );
+}
 function isStoredDelegateLiteral(type, expression) {
   if (type.name !== "NeoDelegate") return false;
   let current = expression;
@@ -50374,10 +50420,20 @@ function lowerStructuredLeafDefault(context, kind, expression, expectedType, own
   });
 }
 function requiredComponentNumber(context, expression, ownerClass, label, path) {
+  if (positionRequiresEvaluation(
+    context,
+    expression,
+    STRUCTURED_LEAF_COMPONENT_TYPE,
+    ownerClass
+  )) {
+    throw new Error(
+      `${label} has a computed component. Structured leaf components must be numeric literals.`
+    );
+  }
   const value = lowerExpressionValue(
     context,
     expression,
-    { name: "float", nullable: false, arguments: [] },
+    STRUCTURED_LEAF_COMPONENT_TYPE,
     ownerClass,
     path
   );
@@ -50965,7 +51021,7 @@ function* zip(left, right) {
     yield [left[index], right[index]];
   }
 }
-var UNSET_LIST_COLUMN_WIDTH, EMPTY_GENERIC_TYPE_ENVIRONMENT, primitiveMemberKinds;
+var UNSET_LIST_COLUMN_WIDTH, EMPTY_GENERIC_TYPE_ENVIRONMENT, DICTIONARY_KEY_TYPE, STRUCTURED_LEAF_COMPONENT_TYPE, primitiveMemberKinds;
 var init_lower_members = __esm({
   "src/project-source/lower-members.ts"() {
     "use strict";
@@ -50983,6 +51039,16 @@ var init_lower_members = __esm({
     init_key_reference_spelling();
     UNSET_LIST_COLUMN_WIDTH = -1;
     EMPTY_GENERIC_TYPE_ENVIRONMENT = /* @__PURE__ */ new Map();
+    DICTIONARY_KEY_TYPE = {
+      name: "string",
+      nullable: false,
+      arguments: []
+    };
+    STRUCTURED_LEAF_COMPONENT_TYPE = {
+      name: "float",
+      nullable: false,
+      arguments: []
+    };
     primitiveMemberKinds = /* @__PURE__ */ new Set([
       "null",
       "bool",
@@ -55239,9 +55305,14 @@ function buildEvaluatorBaseIndexes(members, values, valueById = new Map(
     parentLinksByChildId: /* @__PURE__ */ new Map(),
     indexedRowIds: /* @__PURE__ */ new Set(),
     indexedOverlayValues: /* @__PURE__ */ new Map(),
+    indexedOverlayRowCount: 0,
     shadowedBaseRowIds: /* @__PURE__ */ new Set(),
     listIdentityByArray: /* @__PURE__ */ new WeakMap(),
-    declaredListByArray: /* @__PURE__ */ new WeakMap()
+    declaredListByArray: /* @__PURE__ */ new WeakMap(),
+    rowsBySourceValueId: /* @__PURE__ */ new Map(),
+    ownershipRootIdsByRowId: /* @__PURE__ */ new Map(),
+    ownedValueAttachmentsByValueId: /* @__PURE__ */ new Map(),
+    memberByRowId: /* @__PURE__ */ new Map()
   };
   const membersByValueId = /* @__PURE__ */ new Map();
   for (const member of members) {
@@ -55260,7 +55331,8 @@ function buildEvaluatorBaseIndexes(members, values, valueById = new Map(
     memberByValueId: indexes.memberByValueId,
     membersByValueId,
     parentLinksByChildId: indexes.parentLinksByChildId,
-    indexedRowIds: indexes.indexedRowIds
+    indexedRowIds: indexes.indexedRowIds,
+    rowsBySourceValueId: indexes.rowsBySourceValueId
   };
 }
 function evaluatorIndexes(ctx) {
@@ -55280,10 +55352,16 @@ function evaluatorIndexes(ctx) {
     indexedRowIds: /* @__PURE__ */ new Set(),
     baseIndexedRowIds: base?.indexedRowIds,
     indexedOverlayValues: /* @__PURE__ */ new Map(),
+    indexedOverlayRowCount: 0,
     shadowedBaseRowIds: /* @__PURE__ */ new Set(),
     overlayRevision,
     listIdentityByArray: liveListIndexes?.identity ?? /* @__PURE__ */ new WeakMap(),
-    declaredListByArray: liveListIndexes?.declared ?? /* @__PURE__ */ new WeakMap()
+    declaredListByArray: liveListIndexes?.declared ?? /* @__PURE__ */ new WeakMap(),
+    rowsBySourceValueId: /* @__PURE__ */ new Map(),
+    baseRowsBySourceValueId: base?.rowsBySourceValueId,
+    ownershipRootIdsByRowId: /* @__PURE__ */ new Map(),
+    ownedValueAttachmentsByValueId: /* @__PURE__ */ new Map(),
+    memberByRowId: /* @__PURE__ */ new Map()
   };
   if (base === void 0) {
     for (const member of ctx.vm.members) {
@@ -55308,19 +55386,46 @@ function evaluatorIndexes(ctx) {
 }
 function syncLazyOverlayReferences(indexes, overlay) {
   if (!(overlay instanceof LazyValueOverlay)) return;
-  for (const row of overlay.values()) {
-    if (indexes.indexedOverlayValues.get(row.id) === row.value) continue;
+  const materializedRows = overlay.materializedRowsSince(
+    indexes.indexedOverlayRowCount
+  );
+  for (const row of materializedRows) {
     indexes.indexedOverlayValues.set(row.id, row.value);
     if (typeof row.value === "object" && row.value !== null) {
       indexes.rowByValueReference.set(row.value, row);
     }
   }
+  indexes.indexedOverlayRowCount += materializedRows.length;
 }
 function indexEvaluatorRow(indexes, row, allowBaseShadow = false) {
+  indexes.ownedValueAttachmentsByValueId.delete(row.id);
+  if (Array.isArray(row.value)) {
+    for (const childId of row.value) {
+      if (typeof childId === "string") {
+        indexes.ownedValueAttachmentsByValueId.delete(childId);
+      }
+    }
+  } else if (typeof row.value === "object" && row.value !== null) {
+    for (const childId of Object.values(row.value)) {
+      if (typeof childId === "string") {
+        indexes.ownedValueAttachmentsByValueId.delete(childId);
+      }
+    }
+  }
+  indexes.ownershipRootIdsByRowId.clear();
+  indexes.memberByRowId.clear();
   if (indexes.indexedRowIds.has(row.id) || !allowBaseShadow && indexes.baseIndexedRowIds?.has(row.id) === true) {
     return;
   }
   indexes.indexedRowIds.add(row.id);
+  if (typeof row.sourceValueId === "string") {
+    const rows = indexes.rowsBySourceValueId.get(row.sourceValueId) ?? [];
+    rows.push(row);
+    indexes.rowsBySourceValueId.set(row.sourceValueId, rows);
+  }
+  if (typeof row.containerId === "string") {
+    addEvaluatorParentLink(indexes, row.id, row.containerId, "");
+  }
   if (typeof row.value === "object" && row.value !== null) {
     indexes.rowByValueReference.set(row.value, row);
   }
@@ -55354,6 +55459,57 @@ function evaluatorParentLinks(indexes, childId) {
   if (local.length === 0) return base;
   return [...base, ...local];
 }
+function evaluatorRowsForSourceValueId(indexes, sourceValueId) {
+  const base = (indexes.baseRowsBySourceValueId?.get(sourceValueId) ?? []).filter((row) => !indexes.shadowedBaseRowIds.has(row.id));
+  const local = indexes.rowsBySourceValueId.get(sourceValueId) ?? [];
+  if (base.length === 0) return local;
+  if (local.length === 0) return base;
+  return [...base, ...local];
+}
+function evaluatorOwnershipRootIds(rowId, indexes) {
+  const cached = indexes.ownershipRootIdsByRowId.get(rowId);
+  if (cached !== void 0) return cached;
+  const roots = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  const visit = (currentId) => {
+    if (visiting.has(currentId)) return;
+    visiting.add(currentId);
+    const parents = evaluatorParentLinks(indexes, currentId);
+    if (parents.length === 0) roots.add(currentId);
+    else for (const parent of parents) visit(parent.parentId);
+    visiting.delete(currentId);
+  };
+  visit(rowId);
+  if (roots.size === 0) roots.add(rowId);
+  indexes.ownershipRootIdsByRowId.set(rowId, roots);
+  return roots;
+}
+function resolveRuntimeReferenceRow(sourceValueId, ctx) {
+  const direct = evalValueById(
+    ctx.vm,
+    sourceValueId,
+    ctx.__runtimeSessionValues,
+    ctx.__valueOverlay
+  );
+  const receiver = trackedRowForValueReference(ctx.thisValue, ctx);
+  if (receiver === null) return direct;
+  const indexes = evaluatorIndexes(ctx);
+  const receiverRoots = evaluatorOwnershipRootIds(receiver.id, indexes);
+  const matches = evaluatorRowsForSourceValueId(indexes, sourceValueId).filter(
+    (candidate) => {
+      const candidateRoots = evaluatorOwnershipRootIds(candidate.id, indexes);
+      for (const rootId of candidateRoots) {
+        if (receiverRoots.has(rootId)) return true;
+      }
+      return false;
+    }
+  );
+  if (matches.length === 0) return direct;
+  if (matches.length === 1) return matches[0] ?? direct;
+  throw new NSGetterRuntimeError(
+    `Value reference '${sourceValueId}' is ambiguous within the constructed object graph.`
+  );
+}
 function invalidateEvaluatorIndexes(ctx) {
   if (ctx.__valueOverlay instanceof LazyValueOverlay) {
     ctx.__valueOverlay.markMutated();
@@ -55564,6 +55720,8 @@ function withEvaluationRuntime(ctx, writes) {
       ownedValueAttachments: /* @__PURE__ */ new Map(),
       constructionStack: [],
       loopIterations: 0,
+      budgetedConstructedRowIds: /* @__PURE__ */ new Set(),
+      budgetedProducedEntriesByRowId: /* @__PURE__ */ new Map(),
       budget: createExecutionBudget(ctx.executionBudgetLimits)
     },
     __indexes: ctx.__executionState === void 0 || ctx.__valueOverlay === void 0 ? void 0 : ctx.__indexes
@@ -57211,12 +57369,7 @@ function evalPointer(pointer, scope, ctx) {
       return scope.get(pointer.variableId);
     }
     case "reference" /* reference */: {
-      const row = evalValueById(
-        ctx.vm,
-        pointer.valueId,
-        ctx.__runtimeSessionValues,
-        ctx.__valueOverlay
-      );
+      const row = resolveRuntimeReferenceRow(pointer.valueId, ctx);
       if (!row) {
         throw new NSGetterRuntimeError(
           `Missing value reference: ${pointer.valueId}`
@@ -58432,7 +58585,16 @@ function resolveLocalizedRowValueForMember(row, member, ctx) {
   if (member.localizable === false) return value;
   return resolveLocalizedTextId(value, ctx);
 }
-function memberForValueRow(row, ctx, visited = /* @__PURE__ */ new Set()) {
+function memberForValueRow(row, ctx) {
+  const indexes = evaluatorIndexes(ctx);
+  if (indexes.memberByRowId.has(row.id)) {
+    return indexes.memberByRowId.get(row.id) ?? null;
+  }
+  const member = resolveMemberForValueRow(row, ctx, /* @__PURE__ */ new Set());
+  indexes.memberByRowId.set(row.id, member);
+  return member;
+}
+function resolveMemberForValueRow(row, ctx, visited) {
   if (visited.has(row.id)) return null;
   visited.add(row.id);
   const indexes = evaluatorIndexes(ctx);
@@ -58452,7 +58614,11 @@ function memberForValueRow(row, ctx, visited = /* @__PURE__ */ new Set()) {
       ctx.__valueOverlay
     );
     if (parent === null) continue;
-    const parentMember = memberForValueRow(parent, ctx, new Set(visited));
+    const parentMember = resolveMemberForValueRow(
+      parent,
+      ctx,
+      new Set(visited)
+    );
     if (parentMember !== null && isMemberList(parentMember)) {
       return evalMemberById(ctx.vm, parentMember.entryMemberId);
     }
@@ -59482,23 +59648,29 @@ function publishConstructedRows(args) {
       "Class construction requires an effect-capable evaluator Session scope."
     );
   }
+  let newlyConstructedRows = 0;
+  let newlyProducedEntries = 0;
+  for (const row of createdValues) {
+    if (!state.budgetedConstructedRowIds.has(row.id)) {
+      state.budgetedConstructedRowIds.add(row.id);
+      newlyConstructedRows += 1;
+    }
+    const currentEntries = Array.isArray(row.value) ? row.value.length : typeof row.value === "object" && row.value !== null ? Object.keys(row.value).length : 0;
+    const priorEntries = state.budgetedProducedEntriesByRowId.get(row.id) ?? 0;
+    if (currentEntries <= priorEntries) continue;
+    newlyProducedEntries += currentEntries - priorEntries;
+    state.budgetedProducedEntriesByRowId.set(row.id, currentEntries);
+  }
   consumeBudget(
     ctx,
     "constructedSessionRows",
-    createdValues.length,
+    newlyConstructedRows,
     "constructed Session row"
   );
-  let producedEntries = 0;
-  for (const row of createdValues) {
-    if (Array.isArray(row.value)) producedEntries += row.value.length;
-    else if (typeof row.value === "object" && row.value !== null) {
-      producedEntries += Object.keys(row.value).length;
-    }
-  }
   consumeBudget(
     ctx,
     "producedCollectionEntries",
-    producedEntries,
+    newlyProducedEntries,
     "produced collection entry"
   );
   const retained = retainedIds;
@@ -60186,15 +60358,16 @@ function evaluateInitializerInContext(init, member, ctx, createdValues, argument
   }
   if (rootRow === null) {
     const existingValueRow = trackedRowForValueReference(result.value, ctx);
+    const existingRuntimeClassId = existingValueRow === null ? null : classIdForValueRow(existingValueRow, ctx) ?? null;
     const existingConstructorRootId = existingValueRow === null ? null : constructorGroupForRow(existingValueRow.id, ctx);
     if (existingValueRow !== null && existingConstructorRootId === existingValueRow.id) {
       return {
         value: result.value,
-        classId: existingValueRow.classId ?? null,
+        classId: existingRuntimeClassId,
         existingValueRow
       };
     }
-    return { value: result.value, classId: null };
+    return { value: result.value, classId: existingRuntimeClassId };
   }
   ctx.__runtimeSessionValues?.delete(rootRow.id);
   ctx.__executionState?.constructorGroups.delete(rootRow.id);
@@ -60537,6 +60710,9 @@ function assertOwnedValueAttachable(valueId, destination, destinationName2, ctx,
   }
 }
 function currentOwnedValueAttachments(valueId, ctx) {
+  const indexes = evaluatorIndexes(ctx);
+  const cached = indexes.ownedValueAttachmentsByValueId.get(valueId);
+  if (cached !== void 0) return [...cached];
   const found = /* @__PURE__ */ new Map();
   const add = (attachment) => {
     found.set(attachment.identity, attachment);
@@ -60575,9 +60751,7 @@ function currentOwnedValueAttachments(valueId, ctx) {
     }
   }
   const parentIds = new Set(
-    evaluatorParentLinks(evaluatorIndexes(ctx), valueId).map(
-      (link) => link.parentId
-    )
+    evaluatorParentLinks(indexes, valueId).map((link) => link.parentId)
   );
   for (const parentId of parentIds) {
     const parent = evalValueById(
@@ -60588,21 +60762,25 @@ function currentOwnedValueAttachments(valueId, ctx) {
     );
     if (parent === null) continue;
     if (parent.id === valueId) continue;
-    let member = activeStaticBindingRoot(parent.id, ctx)?.member ?? memberForValueRow(parent, ctx);
-    if (member !== null) {
-      try {
-        member = resolveMember2(member, ctx.vm.members);
-        if (parent.genericBindings !== void 0) {
-          member = substituteMember(
-            member,
-            envFromStamp(parent.genericBindings),
-            ctx.vm.members
-          );
+    let member = null;
+    let classId = parent.classId;
+    if (classId === void 0) {
+      member = activeStaticBindingRoot(parent.id, ctx)?.member ?? memberForValueRow(parent, ctx);
+      if (member !== null) {
+        try {
+          member = resolveMember2(member, ctx.vm.members);
+          if (parent.genericBindings !== void 0) {
+            member = substituteMember(
+              member,
+              envFromStamp(parent.genericBindings),
+              ctx.vm.members
+            );
+          }
+        } catch {
         }
-      } catch {
       }
+      classId = member !== null && isMemberClassBase(member) ? member.classId : void 0;
     }
-    const classId = parent.classId ?? (member !== null && isMemberClassBase(member) ? member.classId : void 0);
     if (classId !== void 0 && typeof parent.value === "object" && parent.value !== null && !Array.isArray(parent.value)) {
       for (const [key, childId] of Object.entries(parent.value)) {
         if (childId !== valueId) continue;
@@ -60633,7 +60811,9 @@ function currentOwnedValueAttachments(valueId, ctx) {
       }
     }
   }
-  return [...found.values()];
+  const attachments = [...found.values()];
+  indexes.ownedValueAttachmentsByValueId.set(valueId, attachments);
+  return attachments;
 }
 function constructorArgumentStorage(valueId, ctx, visiting = /* @__PURE__ */ new Set()) {
   if (ctx.__runtimeSessionValues?.has(valueId)) return "session" /* Session */;
@@ -61143,13 +61323,15 @@ function cloneClassValueGraph(receiver, expectedClassId, ctx) {
       `Class.Clone source value '${sourceId3}' could not be read.`
     );
   }
-  const runtimeClassId = classIdForValueRow(source, ctx);
-  if (runtimeClassId === void 0) {
+  const resolvedRuntimeClassId = classIdForValueRow(source, ctx);
+  const runtimeClassId = resolvedRuntimeClassId ?? expectedClassId;
+  if (runtimeClassId !== expectedClassId && !resolveInheritanceChain(runtimeClassId, ctx.vm.classes).some(
+    (candidate) => candidate.id === expectedClassId
+  )) {
     throw new NSGetterRuntimeError(
-      `Class.Clone source value '${sourceId3}' has no Class runtime type.`
+      `Class.Clone source value '${sourceId3}' has runtime Class '${runtimeClassId}', which is not assignable to '${expectedClassId}'.`
     );
   }
-  void expectedClassId;
   const destination = ctx.__runtimeSessionValues ?? (() => {
     throw new NSGetterRuntimeError(
       "Class.Clone requires an evaluator Session value registry."
@@ -61272,7 +61454,10 @@ function cloneClassValueGraph(receiver, expectedClassId, ctx) {
     return clone;
   };
   const rootMember = memberForValueRow(source, ctx);
-  return cloneRow(source, rootMember).value;
+  const typedSource = source.classId === void 0 ? { ...source, classId: runtimeClassId } : source;
+  const clonedRoot = cloneRow(typedSource, rootMember);
+  clonedRoot.classId ??= runtimeClassId;
+  return clonedRoot.value;
 }
 function ownedObjectChildMember(row, sourceMember, key, ctx) {
   if (sourceMember !== null && isMemberDictionary(sourceMember)) {
@@ -61486,7 +61671,7 @@ var init_evaluateNSGetter = __esm({
       workUnits: 1e5,
       collectionVisits: 1e5,
       producedCollectionEntries: 1e4,
-      constructedSessionRows: 1e3,
+      constructedSessionRows: 4096,
       producedStringCharacters: 1024 * 1024
     });
     liveListIndexesByProject = /* @__PURE__ */ new WeakMap();
@@ -61499,6 +61684,7 @@ var init_evaluateNSGetter = __esm({
       }
       vm;
       revision = 0;
+      materializedRows = [];
       sourceIndexes;
       sourceValueByClone = /* @__PURE__ */ new WeakMap();
       get(id2) {
@@ -61514,8 +61700,12 @@ var init_evaluateNSGetter = __esm({
           this.sourceValueByClone.set(value, source.value);
         }
         super.set(id2, clone);
+        this.materializedRows.push(clone);
         return clone;
       }
+      materializedRowsSince(index) {
+        return this.materializedRows.slice(index);
+      }
       cloneForValueReference(value) {
         const source = this.ensureSourceIndexes().byReference.get(value);
         return source === void 0 ? void 0 : this.get(source.id)?.value;
@@ -63210,7 +63400,11 @@ function readProjectDocument(value, options = {}) {
       isInternalRecordRelation
     ),
     values: readArrayField(value, "values", isMemberValue),
-    enums: readArrayField(value, "enums", isEnum),
+    enums: readArrayField(
+      value,
+      "enums",
+      options.identities === "prospective" ? isProspectiveEnum : isEnum
+    ),
     interfaces: readArrayField(value, "interfaces", isNeoInterface),
     dialogues: readArrayField(value, "dialogues", isDialogue),
     dialogueRecords: readOptionalArrayField(
@@ -69928,7 +70122,9 @@ function materializedInitializerReconciliationFailuresV4(args) {
     [...args.reconciliations.values()].map((entry) => [entry.valueId, entry])
   );
   const candidateValueIds = new Set(
-    [...reconciliationByValueId.values()].filter((reconciliation) => reconciliation.storedConstructorArgs !== null).map((reconciliation) => reconciliation.valueId)
+    [...reconciliationByValueId.values()].filter(
+      (reconciliation) => reconciliation.storedConstructorArgs !== null || reconciliation.requiresCanonicalConstruction === true
+    ).map((reconciliation) => reconciliation.valueId)
   );
   const candidateOwners = resolveOwnerMembersForValues(
     document,
@@ -69968,13 +70164,24 @@ function materializedInitializerReconciliationFailuresV4(args) {
       }
     }
   }
+  const authoredConstructionChangedByValueId = /* @__PURE__ */ new Map();
   const replayableValueIds = /* @__PURE__ */ new Set();
   for (const valueId of candidateValueIds) {
     const reconciliation = reconciliationByValueId.get(valueId);
     const owner = candidateOwners.get(valueId);
     if (reconciliation === void 0 || owner === void 0) continue;
-    const authoredConstructionChanged = args.manifest !== void 0 && canonicalExpressions.get(valueId) !== constructorExpressionSlice(reconciliation.code);
-    if (authoredConstructionChanged || recompileTargets.valueIds.has(valueId)) {
+    const canonicalExpression = canonicalExpressions.get(valueId);
+    if (args.manifest !== void 0 && canonicalExpression === void 0) {
+      throw new Error(
+        `Cannot reconcile stored construction for value "${valueId}": its canonical pulled constructor expression is unavailable.`
+      );
+    }
+    const authoredConstructionChanged = args.manifest !== void 0 && canonicalExpression !== constructorExpressionSlice(reconciliation.code);
+    authoredConstructionChangedByValueId.set(
+      valueId,
+      authoredConstructionChanged
+    );
+    if (reconciliation.storedConstructorArgs !== null && (authoredConstructionChanged || recompileTargets.valueIds.has(valueId))) {
       replayableValueIds.add(valueId);
     }
   }
@@ -69982,7 +70189,26 @@ function materializedInitializerReconciliationFailuresV4(args) {
   const compilationProject = replayableValueIds.size === 0 ? void 0 : args.useBuildCaches === false ? createNeoScriptCompilationProject(document) : loadOrBuildNeoScriptProjectV1(args.workspace.root, document);
   const failures = [];
   for (const reconciliation of args.reconciliations.values()) {
-    if (reconciliation.storedConstructorArgs === null) continue;
+    if (reconciliation.storedConstructorArgs === null) {
+      if (reconciliation.requiresCanonicalConstruction !== true) continue;
+      if (authoredConstructionChangedByValueId.get(reconciliation.valueId) !== true) {
+        continue;
+      }
+      const position2 = composeReferenceSitePosition(
+        reconciliation.site,
+        args.sourceTextByUri
+      );
+      failures.push(
+        new SchemaSourceError(
+          `construction-arguments-conflict: Value "${reconciliation.valueId}" is already materialized without durable constructor arguments, and this construction no longer matches its pulled canonical projection. Delete and recreate the value to change its construction.`,
+          position2.file,
+          position2.line,
+          position2.column,
+          "construction-arguments-conflict"
+        )
+      );
+      continue;
+    }
     if (!replayableValueIds.has(reconciliation.valueId)) continue;
     const owner = owners.get(reconciliation.valueId);
     if (owner === void 0) {
@@ -70525,7 +70751,12 @@ function computeWorkspaceStatus(workspace, options) {
     seeds: /* @__PURE__ */ new Map()
   };
   let projectAnalysisV4 = null;
-  const valueLowerRegistry = createValueLowerRegistryV4();
+  const valueLowerRegistry = createValueLowerRegistryV4({
+    materializedConstructorExpressions: options.useBuildCaches === false ? /* @__PURE__ */ new Map() : readMaterializedConstructionBuildCacheV1(
+      workspace.root,
+      workspace.state
+    ) ?? /* @__PURE__ */ new Map()
+  });
   try {
     if (!baseManifest) {
       throw new Error(
@@ -71593,6 +71824,7 @@ var init_workspace_status_core = __esm({
     init_push_change_intent();
     init_initializer_replay();
     init_compiler_adapter();
+    init_materialized_construction_cache();
     IGNORED_SCHEMA_DIRECTORIES = /* @__PURE__ */ new Set([
       ".git",
       ".neo",
@@ -81675,13 +81907,55 @@ function compilePulledMemberInitializerBodyV4(document, memberId, compilationPro
   });
 }
 function readPulledProjectDocumentV4(records2) {
-  return readProjectDocument(
-    // Replay compilation mutates authored `init` envelopes with transient IR.
-    // Keep that evaluator-local: the input records are also the source commit
-    // payload, where compiled bodies are deliberately absent.
-    structuredClone(pulledProjectDocumentRaw(replayWorkspace(records2))),
-    { constructors: "authored-or-compiled" }
+  const raw = structuredClone(
+    pulledProjectDocumentRaw(replayWorkspace(records2))
+  );
+  return readProjectDocument(completeProspectiveLocalizedTexts(raw), {
+    constructors: "authored-or-compiled",
+    identities: "prospective"
+  });
+}
+function completeProspectiveLocalizedTexts(raw) {
+  const localizedTexts = raw.localizedTexts;
+  if (!Array.isArray(localizedTexts)) return raw;
+  const incomplete = localizedTexts.find((text) => !isLocalizedText(text));
+  if (incomplete === void 0) return raw;
+  const config = localizedTextEnvelopeConfig(
+    raw.localizationConfig,
+    prospectiveLocalizedTextId(incomplete)
   );
+  return {
+    ...raw,
+    localizedTexts: localizedTexts.map(
+      (text) => isLocalizedText(text) ? text : completeLocalizedTextCreateEnvelope(text, config)
+    )
+  };
+}
+function localizedTextEnvelopeConfig(value, textId) {
+  if (!isObjectRecord2(value)) {
+    throw new Error(
+      `Localized text "${textId}" needs the server create envelope, but the project carries no localization config record to mint it from.`
+    );
+  }
+  if (typeof value.mainLocale !== "string") {
+    throw new Error(
+      `Localized text "${textId}" needs the server create envelope, but the project localization config declares no main locale.`
+    );
+  }
+  if (typeof value.mainLocaleDefaultStatusId !== "string") {
+    throw new Error(
+      `Localized text "${textId}" needs the server create envelope, but the project localization config declares no main-locale default status.`
+    );
+  }
+  return {
+    mainLocale: value.mainLocale,
+    mainLocaleDefaultStatusId: value.mainLocaleDefaultStatusId
+  };
+}
+function prospectiveLocalizedTextId(value) {
+  if (!isObjectRecord2(value)) return "<non-object>";
+  if (typeof value.id !== "string") return "<unidentified>";
+  return value.id;
 }
 function replayWorkspace(records2) {
   const stateRecords = {};
@@ -81720,6 +81994,7 @@ var init_initializer_replay = __esm({
     init_value_row_owner_members();
     init_inheritance();
     init_project_document_read();
+    init_localization2();
     init_server_preparation_preflight();
     init_projection();
     init_constructors2();
@@ -81868,11 +82143,20 @@ function emitStoredConstructorExpression(context, member, valueId) {
     value,
     instanceGenericEnvironment(context, classId, resolvedMember, void 0)
   );
-  const targetValueIds = animationConstructorProjectionTargetValueIds(
+  if (!isObjectRecord2(value.value)) {
+    throw new Error(
+      `Stored materialized value ${valueId} has no Class body to project.`
+    );
+  }
+  const hasStoredConstruction = isObjectRecord2(value.constructorArgs);
+  const projection = hasStoredConstruction ? null : constructorProjectionSource(
     context,
     classId,
-    value
+    value.value,
+    /* @__PURE__ */ new Set([valueId]),
+    storedEnvironment
   );
+  const targetValueIds = projection?.targetValueIds ?? animationConstructorProjectionTargetValueIds(context, classId, value);
   const environment = inferAnimationChildOverrideEmitEnvironment(
     context,
     classId,
@@ -81894,12 +82178,13 @@ function emitStoredConstructorExpression(context, member, valueId) {
     /* @__PURE__ */ new Set([valueId]),
     false
   );
-  if (constructor2 === null) {
+  if (constructor2 !== null) return constructor2;
+  if (projection === null || projection.arguments.length === 0 && schemaClass2.requiredConstructorId === void 0) {
     throw new Error(
       `Stored materialized value ${valueId} has no constructor arguments.`
     );
   }
-  return constructor2;
+  return projection.arguments.length === 0 ? `new ${className}()` : constructorCallSource(`new ${className}`, projection.arguments);
 }
 function animationConstructorProjectionTargetValueIds(context, classId, value) {
   if (context.manifestClasses.get(classId)?.system?.worldKind !== "animationChildOverride" || !isObjectRecord2(value.value)) {
@@ -82040,8 +82325,9 @@ function qualifiedProjectFileSymbolsV4(records2) {
   }
   return result;
 }
-function createValueLowerRegistryV4() {
+function createValueLowerRegistryV4(options = {}) {
   return {
+    materializedConstructorExpressions: options.materializedConstructorExpressions ?? /* @__PURE__ */ new Map(),
     pendingValues: /* @__PURE__ */ new Map(),
     pendingLocalizedTexts: /* @__PURE__ */ new Map(),
     pendingBindingMembersByClassId: /* @__PURE__ */ new Map(),
@@ -82145,7 +82431,8 @@ function buildValueLowerContext(state, manifest, options = {}) {
     referenceObligations: registry.referenceObligations,
     loweringFailures: registry.loweringFailures,
     pendingValueIdentitySites: registry.pendingValueIdentitySites,
-    initializerReconciliations: registry.initializerReconciliations
+    initializerReconciliations: registry.initializerReconciliations,
+    materializedConstructorExpressions: registry.materializedConstructorExpressions
   };
 }
 function indexMemberOverrides(members) {
@@ -82792,6 +83079,13 @@ function constructorArgumentValueSlices(authoredSlice) {
     );
   });
 }
+function unattachedAuthoredRowId(authoredSlice) {
+  if (authoredSlice === void 0) return null;
+  const match = LEADING_AUTHORED_ROW_ID.exec(
+    normalizeInitializerSource(authoredSlice)
+  );
+  return match?.[1] ?? null;
+}
 function initializerExpressionSlice(authoredSlice) {
   if (authoredSlice === void 0) return void 0;
   let text = normalizeInitializerSource(authoredSlice);
@@ -83162,6 +83456,12 @@ function lowerSeedRow(context, member, sourceExpression, source, valueId, path,
     memberClassName(context, resolvedMember),
     bindingRuntimeIdentifiers(context, source)
   )) {
+    const unattachedId = annotated.id === null ? unattachedAuthoredRowId(authoredSlice) : null;
+    if (unattachedId !== null) {
+      throw new Error(
+        `Value ${path} in ${source.label} writes @id(${JSON.stringify(unattachedId)}) on part of a computed expression rather than on the row. Parenthesize the expression so the annotation names the whole row.`
+      );
+    }
     if (annotated.id === null && isPendingId(valueId) && !context.pendingValueIdentitySites.has(valueId)) {
       context.pendingValueIdentitySites.set(valueId, {
         id: valueId,
@@ -83590,20 +83890,28 @@ function lowerValueRow(context, member, sourceExpression, expectedValueId, sourc
     }
     indexInitAuthoredRowIds(context, code, source.label);
     const storedConstructorArgs = isObjectRecord2(base.constructorArgs) ? base.constructorArgs : null;
-    const materializedPlainClass = resolvedMember.kind === "class" && isObjectRecord2(base.value) && context.classes.get(
+    const materializedClass = resolvedMember.kind === "class" && isObjectRecord2(base.value);
+    const materializedPlainClass = materializedClass && context.classes.get(
       typeof base.classId === "string" ? base.classId : resolvedMember.classId
     )?.requiredConstructorId === void 0;
-    if (storedConstructorArgs !== null || materializedPlainClass) {
+    const requiresCanonicalConstruction = storedConstructorArgs === null && materializedClass && !materializedPlainClass;
+    const canonicalConstruction = context.materializedConstructorExpressions.get(expectedValueId);
+    const authoredConstruction = constructorExpressionSlice(code);
+    const canonicalConstructionMatches = canonicalConstruction !== void 0 && canonicalConstruction === authoredConstruction;
+    const canonicalConstructionMissing = requiresCanonicalConstruction && canonicalConstruction === void 0;
+    const preserveRequiredStoredConstruction = requiresCanonicalConstruction && source.purpose === "stored";
+    if (storedConstructorArgs !== null || materializedPlainClass || canonicalConstructionMatches || canonicalConstructionMissing || preserveRequiredStoredConstruction) {
       if (resolvedMember.kind !== "class") {
         throw new Error(
           `Value ${expectedValueId} stores constructor arguments but its declared member ${resolvedMember.name} is not a Class.`
         );
       }
-      if (source.purpose === "stored") {
+      if (source.purpose === "stored" || canonicalConstructionMissing) {
         context.initializerReconciliations.set(expectedValueId, {
           valueId: expectedValueId,
           code,
           storedConstructorArgs: storedConstructorArgs === null ? null : structuredClone(storedConstructorArgs),
+          ...requiresCanonicalConstruction ? { requiresCanonicalConstruction: true } : {},
           settleFields: expression.kind === "new" ? (expression.initializer ?? []).map(
             (assignment) => assignment.name
           ) : [],
@@ -85781,9 +86089,6 @@ function classValue(context, member, value, visited, targetTyped, outerEnvironme
       { cause: error }
     );
   }
-  if (storedConstruction !== null && typeof value.id === "string") {
-    context.materializedConstructors.set(value.id, storedConstruction);
-  }
   const replayConstruction = storedConstruction === null ? null : storedConstructorCallSource(
     context,
     schemaClass2,
@@ -85862,6 +86167,9 @@ ${fields.map((field) => indentNeoSourceNonEmptyLines(field, 2)).join(",\n")}
 }`;
   }
   const constructor2 = storedConstruction !== null ? storedConstruction : projection.arguments.length > 0 ? constructorCallSource(`new ${name}`, projection.arguments) : targetTyped ? "new()" : `new ${name}()`;
+  if (typeof value.id === "string" && (storedConstruction !== null || projection.arguments.length > 0 || schemaClass2.requiredConstructorId !== void 0)) {
+    context.materializedConstructors.set(value.id, constructor2);
+  }
   return fields.length === 0 ? constructor2 : `${storedConstruction !== null || projection.arguments.length > 0 ? constructor2 : targetTyped ? "new()" : `new ${name}`} {
 ${fields.map((field) => indentNeoSourceNonEmptyLines(field, 2)).join(",\n")}
 }`;
@@ -86697,16 +87005,22 @@ function instanceGenericEnvironment(context, classId, member, outerEnvironment)
   const bindings = classGenericBindings(context.manifestClasses, classId);
   const memberId = stringField3(member, "id");
   const manifestMember = context.manifestMembers.get(memberId);
-  if (manifestMember?.kind === "class") {
-    for (const [genericParamId, argument2] of Object.entries(
-      manifestMember.classArguments
+  const rawClassArguments = isObjectRecord2(member.classArguments) ? member.classArguments : null;
+  const classArguments2 = rawClassArguments ?? (manifestMember?.kind === "class" ? manifestMember.classArguments : null);
+  if (classArguments2 !== null) {
+    for (const [genericParamId, rawArgument] of Object.entries(
+      classArguments2
     )) {
+      const argument2 = isObjectRecord2(rawArgument) ? rawArgument : null;
       if (bindings.get(genericParamId)?.kind === "member") continue;
-      if (argument2.kind === "member") {
-        bindings.set(genericParamId, argument2);
+      if (argument2?.kind === "member" && typeof argument2.memberId === "string") {
+        bindings.set(genericParamId, {
+          kind: "member",
+          memberId: argument2.memberId
+        });
         continue;
       }
-      const outerMemberId = outerEnvironment?.get(argument2.genericParamId);
+      const outerMemberId = argument2?.kind === "generic" && typeof argument2.genericParamId === "string" ? outerEnvironment?.get(argument2.genericParamId) : void 0;
       if (outerMemberId !== void 0) {
         bindings.set(genericParamId, {
           kind: "member",
@@ -87169,7 +87483,7 @@ function memberDefaultBody(member) {
   if (!("value" in defaultValue)) return null;
   return defaultValue.value;
 }
-var INFERRED_GENERIC_CLASS_PREFIX, MEMBER_KIND_DICTIONARY, MEMBER_KIND_LIST, MEMBER_KIND_CLASS, CANONICAL_CONSTRUCTOR_INLINE_WIDTH;
+var INFERRED_GENERIC_CLASS_PREFIX, MEMBER_KIND_DICTIONARY, MEMBER_KIND_LIST, MEMBER_KIND_CLASS, LEADING_AUTHORED_ROW_ID, CANONICAL_CONSTRUCTOR_INLINE_WIDTH;
 var init_value_sources = __esm({
   "src/project-source/value-sources.ts"() {
     "use strict";
@@ -87196,6 +87510,7 @@ var init_value_sources = __esm({
     MEMBER_KIND_DICTIONARY = 5;
     MEMBER_KIND_LIST = 6;
     MEMBER_KIND_CLASS = 7;
+    LEADING_AUTHORED_ROW_ID = /^@id\(\s*"((?:[^"\\]|\\.)*)"\s*\)/;
     CANONICAL_CONSTRUCTOR_INLINE_WIDTH = 88;
   }
 });

package/package.json

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

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

@@ -78,7 +78,7 @@ wrappers.
 The marker near the top of `SKILL.md` must exactly match the package version:
 
 ```html
-<!-- reviewed-through-cli: 0.22.6 -->
+<!-- reviewed-through-cli: 0.23.0 -->
 ```
 
 The quoted version above is checked too, so this instruction cannot go stale

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

@@ -108,6 +108,14 @@ construction rather than stored as a closed literal. It runs for every newly
 constructed instance in push, web, and SDK contexts; it does not rewrite
 existing saved instances.
 
+Operator expressions are valid member defaults and store as computed
+initializers, the same way calls do — `public float Derived =
+Flags.Start / Flags.Scale;` is fine. Positions that store no rows still
+require literals: dictionary keys must be string literals and Vector/Color
+components must be numeric literals. When a computed list or dictionary entry
+carries an authored `@id`, parenthesize the expression — `@id("row")
+(A.B / A.C)` — so the annotation names the row rather than its left operand.
+
 Declare overloadable constructors as members when each constructor body owns
 its parameter scope: