@neocompose/cli 0.68.2 → 0.68.3

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## [0.68.3] - 2026-10-05
+
+- `neo push --dry-run` preserves valid authored UUID-v4 IDs on new nested member and dictionary values, including values named by local declarations. Previously, verification dropped the ID and failed with an internal "has no pending id assignment" error. Status and push report malformed new member-value IDs at the annotation, name the affected `Class.Member`, and suggest removing `@id` or providing an unused UUID v4 ([#1189](https://github.com/ryanbliss/neo-compose/issues/1189)).
+
+- A stored nested class value can keep its UUID-v4 when moved between compatible empty fields on existing parents. Its old owning declaration must be removed in the same push. Unsafe ownership changes are refused with an explanation.
+
+- Trusted verification resolves complete pending IDs inside initializer code, so `Reference<T>(key:)` can target a row created in the same push without confusing its ID with the containing value's ID.
+
+- An override of a generic class's function passes the push-time animation check, including an override of an override, as in `class ClampedIntWatcher : MinIntWatcher` where `MinIntWatcher : ValueWatcher<int>`. Before, status warned and test and push stopped with "Prospective animation validation received an invalid member record … (\"Apply\")" in any project with animation classes.
+
 ## [0.68.2] - 2026-10-05
 
 - Local initializer IDs may appear above the variable declaration. Formatting and pull move inline IDs there while preserving the stored row identity. Nested IDs remain on their expressions.

package/dist/neo.mjs

@@ -31690,7 +31690,7 @@ var init_registry = __esm({
   "../packages/manifest/schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.68.2",
+      cliVersion: "0.68.3",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -116847,6 +116847,59 @@ var init_client_commit_preparation = __esm({
   }
 });
 
+// src/project-source/identity-rewriter.ts
+function createIdentityRewriter(assignments, onReplace) {
+  if (assignments.size === 0) return (value) => value;
+  const root = { children: /* @__PURE__ */ new Map() };
+  for (const [source, replacement] of assignments) {
+    let prefix = root;
+    for (let index = 0; index < source.length; index += 1) {
+      const character = source[index];
+      let child2 = prefix.children.get(character);
+      if (child2 === void 0) {
+        child2 = { children: /* @__PURE__ */ new Map() };
+        prefix.children.set(character, child2);
+      }
+      prefix = child2;
+    }
+    prefix.replacement = replacement;
+  }
+  return (value) => {
+    const exact = assignments.get(value);
+    if (exact !== void 0) {
+      onReplace?.(value);
+      return exact;
+    }
+    const parts = [];
+    let copiedThrough = 0;
+    for (let start = 0; start < value.length; start += 1) {
+      let prefix = root.children.get(value[start]);
+      let replacement;
+      let end = start;
+      for (let index = start; prefix !== void 0; index += 1) {
+        if (prefix.replacement !== void 0) {
+          replacement = prefix.replacement;
+          end = index + 1;
+        }
+        prefix = prefix.children.get(value[index + 1]);
+      }
+      if (replacement === void 0) continue;
+      onReplace?.(value.slice(start, end));
+      parts.push(value.slice(copiedThrough, start), replacement);
+      copiedThrough = end;
+      start = end - 1;
+    }
+    if (copiedThrough === 0) return value;
+    parts.push(value.slice(copiedThrough));
+    return parts.join("");
+  };
+}
+var init_identity_rewriter = __esm({
+  "src/project-source/identity-rewriter.ts"() {
+    "use strict";
+  }
+});
+
 // src/project-source/schema-source-validation.ts
 function sourceDiagnosticMapper(analysis) {
   const locations = /* @__PURE__ */ new Map();
@@ -124875,7 +124928,8 @@ function computeWorkspaceStatus(workspace, options) {
           claim.message,
           position.file,
           position.line,
-          position.column
+          position.column,
+          claim.code
         )
       );
     }
@@ -125305,7 +125359,7 @@ function prospectiveAnimationDocumentV4(records2) {
   let project;
   const constructors = [];
   const classes = [];
-  const members = [];
+  const memberData = [];
   const values = [];
   for (const record6 of candidates) {
     if (record6.recordKind === "project") {
@@ -125325,16 +125379,7 @@ function prospectiveAnimationDocumentV4(records2) {
       }
       classes.push(record6.data);
     } else if (record6.recordKind === "member") {
-      const member = hydrateProspectiveMemberOverride(
-        record6.data,
-        memberRecords
-      );
-      if (!isMember(member)) {
-        throw new Error(
-          `Prospective animation validation received an invalid member record ${recordLabel(record6.data)}.`
-        );
-      }
-      members.push(member);
+      memberData.push(record6.data);
     } else if (record6.recordKind === "value") {
       if (!isMemberValue(record6.data)) {
         throw new Error(
@@ -125345,6 +125390,22 @@ function prospectiveAnimationDocumentV4(records2) {
     }
   }
   if (project === void 0) return null;
+  const members = [];
+  const inheritedCallables = [];
+  for (const data of memberData) {
+    const member = hydrateProspectiveMemberOverride(data, memberRecords);
+    if (typeof data.extendsMemberId === "string" && member.returnTypeInfo !== void 0) {
+      inheritedCallables.push(member);
+    } else {
+      members.push(validProspectiveMember(member));
+    }
+  }
+  const closedCallables = inheritedCallables.map(
+    (member) => validProspectiveMember(
+      closeInheritedCallableSignature(member, classes, members)
+    )
+  );
+  members.push(...closedCallables);
   const classesById = new Map(
     classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
   );
@@ -125768,6 +125829,36 @@ function hydrateProspectiveMemberOverride(data, members) {
   }
   return hydrated;
 }
+function validProspectiveMember(member) {
+  if (!isMember(member)) {
+    throw new Error(
+      `Prospective animation validation received an invalid member record ${recordLabel(member)}.`
+    );
+  }
+  return member;
+}
+function closeInheritedCallableSignature(member, classes, members) {
+  if (typeof member.id !== "string") return member;
+  const env = resolveDeclaringClassGenericEnv(member.id, classes);
+  if (env.size === 0) return member;
+  const close = (typeInfo) => substituteInheritedCallableTypeInfo(typeInfo, env, classes, members);
+  const closed = { ...member };
+  if (isNSFunctionReturnTypeInfo(member.returnTypeInfo)) {
+    closed.returnTypeInfo = close(member.returnTypeInfo);
+  }
+  if (Array.isArray(member.argumentTypes)) {
+    closed.argumentTypes = member.argumentTypes.map((argument2) => {
+      if (!isNSFunctionArgumentTypeInfo(argument2)) return argument2;
+      const { name, defaultValue } = argument2;
+      return {
+        ...close(argument2),
+        name,
+        ...defaultValue === void 0 ? {} : { defaultValue }
+      };
+    });
+  }
+  return closed;
+}
 function resolveProspectiveMemberField(start, field, members) {
   let current = start;
   const visited = /* @__PURE__ */ new Set();
@@ -126149,6 +126240,8 @@ var init_workspace_status_core = __esm({
     init_project_documents();
     init_animation_clips();
     init_classes();
+    init_generics();
+    init_neoscript_guards();
     init_members();
     init_value_row_owner_members();
     init_constructors2();
@@ -126255,7 +126348,16 @@ ${blockingErrors.map((error) => error.message).join("\n")}` : `Trusted source lo
   );
   const usedAssignments = /* @__PURE__ */ new Set();
   const positionless = positionIndependentAssignments(assignments);
-  const rewrite = (value) => rewritePending(value, assignments, usedAssignments, positionless);
+  const rewriteEmbedded = createIdentityRewriter(assignments, (id2) => {
+    usedAssignments.add(id2);
+  });
+  const rewrite = (value) => rewritePending(
+    value,
+    assignments,
+    usedAssignments,
+    positionless,
+    rewriteEmbedded
+  );
   const expectedChanges = status.changes.map((change) => {
     const rewrittenData = change.nextData === void 0 ? void 0 : rewrite(change.nextData);
     return {
@@ -126495,7 +126597,7 @@ function relocatedAssignment(pendingId2, assignments, byPosition, used) {
   const relocatedVirtual = pendingVirtualValueId(relocatedRoot, sourceIdentity3);
   return assignments.has(relocatedVirtual) ? relocatedVirtual : null;
 }
-function rewritePending(value, assignments, used, positionless) {
+function rewritePending(value, assignments, used, positionless, rewriteEmbedded) {
   if (typeof value === "string") {
     const exact = assignments.get(value);
     if (exact !== void 0) {
@@ -126518,28 +126620,23 @@ function rewritePending(value, assignments, used, positionless) {
       );
     }
     if (!value.includes("__pending__:")) return value;
-    let rewritten = value;
-    for (const [pendingId2, assignedId] of assignments) {
-      if (!rewritten.includes(pendingId2)) continue;
-      rewritten = rewritten.replaceAll(pendingId2, assignedId);
-      used.add(pendingId2);
-    }
-    return rewritten;
+    return rewriteEmbedded(value);
   }
   if (Array.isArray(value)) {
     return value.map(
-      (entry) => rewritePending(entry, assignments, used, positionless)
+      (entry) => rewritePending(entry, assignments, used, positionless, rewriteEmbedded)
     );
   }
   if (isObjectRecord2(value)) {
     const result = {};
     for (const [key, entry] of Object.entries(value)) {
-      const rewrittenKey = key.startsWith("__pending__:") ? rewritePending(key, assignments, used, positionless) : key;
+      const rewrittenKey = key.startsWith("__pending__:") ? rewritePending(key, assignments, used, positionless, rewriteEmbedded) : key;
       result[rewrittenKey] = rewritePending(
         entry,
         assignments,
         used,
-        positionless
+        positionless,
+        rewriteEmbedded
       );
     }
     return result;
@@ -126775,6 +126872,7 @@ var ProjectSourceCommitVerificationError, ABSENT_DIFFERENCE_VALUE;
 var init_trusted_commit_verification = __esm({
   "src/project-source/trusted-commit-verification.ts"() {
     "use strict";
+    init_identity_rewriter();
     init_schema_source_validation();
     init_projectRecordBuckets();
     init_workspace_status_core();
@@ -128342,6 +128440,8 @@ function createValueLowerRegistryV4(options = {}) {
     initAuthoredRowIds: /* @__PURE__ */ new Map(),
     loweringFailures: [],
     storedRowClaims: /* @__PURE__ */ new Map(),
+    movedValueSites: /* @__PURE__ */ new Map(),
+    storedMoveRoots: /* @__PURE__ */ new Map(),
     placedStoredRowIds: /* @__PURE__ */ new Set(),
     pendingValueIdentitySites: /* @__PURE__ */ new Map(),
     initializerSites: /* @__PURE__ */ new Map(),
@@ -128468,6 +128568,7 @@ function buildValueLowerContext(state, manifest, options = {}) {
     localizationConversionValueIds: registry.localizationConversionValueIds,
     loweredMemberIdByValueId: /* @__PURE__ */ new Map(),
     storedClassSchemaMemberIds: /* @__PURE__ */ new Map(),
+    ordinaryMoveFields: /* @__PURE__ */ new Map(),
     pendingBindingMembersByClassId: registry.pendingBindingMembersByClassId,
     declaredConstructors: declaredConstructorIndex,
     initAuthoredRowIds: seedInitAuthoredRowIds(
@@ -128481,6 +128582,8 @@ function buildValueLowerContext(state, manifest, options = {}) {
     referenceObligations: registry.referenceObligations,
     loweringFailures: registry.loweringFailures,
     storedRowClaims: registry.storedRowClaims,
+    movedValueSites: registry.movedValueSites,
+    storedMoveRoots: registry.storedMoveRoots,
     placedStoredRowIds: registry.placedStoredRowIds,
     pendingValueIdentitySites: registry.pendingValueIdentitySites,
     initializerSites: registry.initializerSites,
@@ -129131,6 +129234,21 @@ function drainValueReferenceObligationsV4(state, manifest, options) {
     })
   });
   const failures = [];
+  const movedRoots = /* @__PURE__ */ new Map();
+  for (const [valueId, move] of options.registry.movedValueSites) {
+    const placements = context.valuePlacements.placementsByValueId.get(valueId) ?? [];
+    let message;
+    if (placements.length !== 1) {
+      message = `Value @id(${JSON.stringify(valueId)}) must have exactly one owning slot after a move; found ${placements.length}. Remove its declaration from the old parent before keeping the same ID on the new owner.`;
+    } else if (singleSlotBindingRoot(context, valueId, movedRoots) !== move.rootValueId) {
+      message = `Value @id(${JSON.stringify(valueId)}) cannot move: moves require one acyclic path under the same root or static binding, through non-overridden class fields with inherited storage and automatic distribution.`;
+    } else continue;
+    failures.push({
+      code: "invalid-value-move",
+      message,
+      ...composeReferenceSitePosition(move.site, options.sourceTextByUri)
+    });
+  }
   for (const recorded of options.registry.loweringFailures) {
     failures.push({
       message: recorded.message,
@@ -129730,27 +129848,17 @@ function lowerRowBackedDefault(context, member, backed, baseData3, binding) {
       const childValueMember = recursivePartialMember(member, childMember);
       const childSlice = assignmentSlices.get(assignment.name);
       const existingId = isObjectRecord2(baseBody) ? baseBody[assignment.name] : void 0;
-      const annotatedId = authoredRowId(context, assignment.value, binding);
-      const storedId = typeof existingId === "string" ? existingId : annotatedId;
-      if (storedId !== null && storedId !== void 0) {
-        if (typeof existingId === "string" || context.state[`value:${storedId}`] !== void 0) {
-          body[assignment.name] = lowerValueRow(
-            context,
-            childValueMember,
-            assignment.value,
-            storedId,
-            binding,
-            environment,
-            childSlice
-          );
-          continue;
-        }
-        if (!isPendingId(storedId) && !isUuidV4Id(storedId)) {
-          context.loweringFailures.push({
-            message: `Default value ${binding.label}.${assignment.name} is annotated @id("${storedId}"), which names no existing row, and a new row's durable identity must be a UUID v4. Fix the id if it meant an existing row, or drop the @id to mint a fresh identity.`,
-            site: referenceSite(binding, assignment.value)
-          });
-        }
+      if (typeof existingId === "string") {
+        body[assignment.name] = lowerValueRow(
+          context,
+          childValueMember,
+          assignment.value,
+          existingId,
+          binding,
+          environment,
+          childSlice
+        );
+        continue;
       }
       const placedId = sourceValueSymbol(context, assignment.value);
       if (placedId !== null) {
@@ -129782,6 +129890,7 @@ function lowerRowBackedDefault(context, member, backed, baseData3, binding) {
     }
     const entryMember = requiredMember(context, member.entryMemberId);
     const existingIds = new Set(backed.body);
+    const placedIds = /* @__PURE__ */ new Set();
     const entrySlices = topLevelEntrySlices(binding.initializer, "[", "]");
     const ids = expression.elements.map((element, index) => {
       const symbolId = sourceValueSymbol(context, element);
@@ -129812,6 +129921,21 @@ function lowerRowBackedDefault(context, member, backed, baseData3, binding) {
           entrySlices[index]
         );
       }
+      if (!existingIds.has(itemId)) {
+        context.storedRowClaims.set(itemId, {
+          code: "invalid-value-move",
+          message: `Value @id(${JSON.stringify(itemId)}) cannot move into another default list. Remove @id to create a new value.`,
+          site: referenceSite(binding, element)
+        });
+        return itemId;
+      }
+      recordRepeatedRow(
+        context,
+        itemId,
+        `Default list ${binding.label}`,
+        referenceSite(binding, element),
+        placedIds
+      );
       return lowerValueRow(
         context,
         entryMember,
@@ -129832,6 +129956,8 @@ function lowerRowBackedDefault(context, member, backed, baseData3, binding) {
     const keyEnum = dictionaryKeyEnum(context, member);
     const baseBody = backed.body;
     const body = {};
+    const existingIds = new Set(Object.values(baseBody));
+    const placedIds = /* @__PURE__ */ new Set();
     const entrySlices = topLevelEntrySlices(binding.initializer, "{", "}");
     let entryIndex = 0;
     for (const entry of expression.entries) {
@@ -129843,6 +129969,23 @@ function lowerRowBackedDefault(context, member, backed, baseData3, binding) {
           `Default dictionary ${binding.label}[${JSON.stringify(key)}] has no existing owned value row. Creating new default rows from source is not implemented by this slice.`
         );
       }
+      if (context.state[`value:${entryId}`] !== void 0 && !existingIds.has(entryId)) {
+        context.storedRowClaims.set(entryId, {
+          code: "invalid-value-move",
+          message: `Value @id(${JSON.stringify(entryId)}) cannot move into another default dictionary. Remove @id to create a new value.`,
+          site: referenceSite(binding, entry.value)
+        });
+        body[key] = entryId;
+        entryIndex += 1;
+        continue;
+      }
+      recordRepeatedRow(
+        context,
+        entryId,
+        `Default dictionary ${binding.label}`,
+        referenceSite(binding, entry.value),
+        placedIds
+      );
       body[key] = lowerValueRow(
         context,
         entryMember,
@@ -130909,8 +131052,64 @@ function structuralMemberByParameterName(context, effectiveClass) {
 function lowerSeedChild(context, member, expression, source, path, rows, localizedTexts, containerId, environment, authoredSlice) {
   const symbolId = sourceValueSymbol(context, expression);
   if (symbolId !== null) return symbolId;
-  const annotatedId = authoredRowId(context, expression, source);
+  const local = context.localValues.resolve(expression, source);
+  const annotatedId = annotatedValue(local.expression).id;
+  if (annotatedId !== null && !isPendingId(annotatedId) && context.state[`value:${annotatedId}`] === void 0 && member.owner.kind === "classMember" && !isUuidV4Id(annotatedId)) {
+    const owner = context.classes.get(member.owner.classId)?.name;
+    const name = owner === void 0 ? member.name : `${owner}.${member.name}`;
+    context.loweringFailures.push({
+      code: "invalid-new-value-id",
+      message: `Value ${name} has @id(${JSON.stringify(annotatedId)}), which names no existing row. A new nested value requires a UUID v4. Remove @id to let Neo assign the value's identity, or provide a valid, unused UUID v4.`,
+      site: referenceSiteAt(
+        local.source,
+        local.expression.kind === "annotated" ? local.expression.annotations.find((entry) => entry.name === "id")?.pos ?? local.expression.pos : local.expression.pos
+      )
+    });
+  }
   const valueId = annotatedId ?? context.structuralStoredIds.get(path) ?? pendingNestedValueId(source, path);
+  if (!context.structuralConstruction && annotatedId !== null && context.state[`value:${annotatedId}`] !== void 0) {
+    const failure = storedClassMoveFailure(
+      context,
+      member,
+      annotatedId,
+      path,
+      containerId
+    );
+    if (failure !== null) {
+      context.storedRowClaims.set(annotatedId, {
+        code: "invalid-value-move",
+        message: failure,
+        site: referenceSite(local.source, local.expression)
+      });
+      return annotatedId;
+    }
+    const rootValueId = singleSlotBindingRoot(
+      context,
+      annotatedId,
+      context.storedMoveRoots
+    );
+    if (rootValueId === null) {
+      context.storedRowClaims.set(annotatedId, {
+        code: "invalid-value-move",
+        message: `Value @id(${JSON.stringify(annotatedId)}) cannot move: moves require an existing path to a root or static binding through non-overridden class fields with inherited storage and automatic distribution.`,
+        site: referenceSite(local.source, local.expression)
+      });
+      return annotatedId;
+    }
+    context.movedValueSites.set(annotatedId, {
+      site: referenceSite(local.source, local.expression),
+      rootValueId
+    });
+    return lowerValueRow(
+      context,
+      member,
+      expression,
+      annotatedId,
+      source,
+      environment,
+      authoredSlice
+    );
+  }
   lowerSeedRow(
     context,
     member,
@@ -130926,6 +131125,99 @@ function lowerSeedChild(context, member, expression, source, path, rows, localiz
   );
   return valueId;
 }
+function singleSlotBindingRoot(context, start, roots) {
+  const placements = context.valuePlacements;
+  const path = /* @__PURE__ */ new Set();
+  let cursor = start;
+  let root = null;
+  while (!path.has(cursor)) {
+    const cached = roots.get(cursor);
+    if (cached !== void 0) {
+      root = cached;
+      break;
+    }
+    if (placements.memberIdsByBoundValueId.has(cursor)) {
+      root = cursor;
+      break;
+    }
+    path.add(cursor);
+    const parents = placements.placementsByValueId.get(cursor) ?? [];
+    const parent = parents[0];
+    if (parents.length !== 1 || parent === void 0) break;
+    if (parent.containerClassId === null) break;
+    const key = `${parent.containerClassId}:${parent.schemaKey}`;
+    let ordinary = context.ordinaryMoveFields.get(key);
+    if (ordinary === void 0) {
+      const member = classMemberByName(
+        context,
+        parent.containerClassId,
+        parent.schemaKey
+      );
+      ordinary = member.overrideOf === null && member.storage === null && member.storageKey === null && member.distribution === null;
+      context.ordinaryMoveFields.set(key, ordinary);
+    }
+    if (!ordinary) break;
+    cursor = parent.containerValueId;
+  }
+  for (const id2 of path) roots.set(id2, root);
+  return root;
+}
+function storedClassMoveFailure(context, member, valueId, path, containerId) {
+  const refuse = (reason) => `Value @id(${JSON.stringify(valueId)}) cannot move: ${reason}. Remove @id to create a new value.`;
+  if (!isUuidV4Id(valueId))
+    return refuse("its identity is derived from its original placement");
+  if (containerId !== void 0)
+    return refuse("unordered-list membership is immutable");
+  if (member.owner.kind !== "classMember")
+    return refuse("the new owner is not a class member");
+  if (member.kind !== "class")
+    return refuse("only nested class values support moves");
+  const base = valueBase(context, valueId);
+  if (typeof base.containerId === "string")
+    return refuse("unordered-list membership is immutable");
+  if ((context.valuePlacements.memberIdsByBoundValueId.get(valueId)?.length ?? 0) > 0)
+    return refuse("a root or static binding owns it");
+  const placement = context.readStoredValuePlacements().placementByChildValueId.get(valueId);
+  if (placement === void 0)
+    return refuse("its old owning class slot could not be resolved");
+  if (placement.source !== "body")
+    return refuse("its old owner supplies it through a constructor");
+  const parent = valueBase(context, placement.parentValueId);
+  const targetParentId = path.slice(0, -(member.name.length + 1));
+  if (context.state[`value:${targetParentId}`] === void 0)
+    return refuse("the new parent is not an existing stored class value");
+  const targetParent = valueBase(context, targetParentId);
+  for (const row of [base, parent, targetParent]) {
+    if (typeof row.sourceValueId === "string")
+      return refuse("a projected value depends on its original owner");
+    if (typeof row.mapKey === "string")
+      return refuse("partitioned values cannot change ownership");
+    if (isObjectRecord2(row.genericBindings) && Object.keys(row.genericBindings).length > 0)
+      return refuse("generic value ownership cannot be changed");
+  }
+  if (typeof targetParent.instanceConstructorId === "string" || isObjectRecord2(targetParent.constructorArgs) && Object.keys(targetParent.constructorArgs).length > 0)
+    return refuse("the new owner has constructor creation data");
+  if (typeof parent.instanceConstructorId === "string" || isObjectRecord2(parent.constructorArgs) && Object.keys(parent.constructorArgs).length > 0)
+    return refuse("its old owner has constructor creation data");
+  const oldMember = placement.memberId === null ? void 0 : context.members.get(placement.memberId);
+  if (oldMember?.kind !== "class")
+    return refuse(
+      "its old owner is not a class member containing a class value"
+    );
+  if (oldMember.storageKey !== member.storageKey)
+    return refuse("the new member declares a different storage key");
+  if (oldMember.distribution !== member.distribution)
+    return refuse("the new member declares a different distribution");
+  if (oldMember.storage !== member.storage)
+    return refuse("the new member uses different storage");
+  if (oldMember.classId !== member.classId)
+    return refuse("the new member declares a different class type");
+  if (Object.keys(oldMember.classArguments).length > 0)
+    return refuse("generic member ownership cannot be changed");
+  if (Object.keys(member.classArguments).length > 0)
+    return refuse("the new member declares generic arguments");
+  return null;
+}
 function unorderedRowSubtreePath(valueId, path, containerId) {
   if (containerId === void 0 || containerId === null) return path;
   return valueId;
@@ -131174,7 +131466,8 @@ function lowerValueBody(context, member, expression, base, source, environment,
         expression,
         base,
         source,
-        environment
+        environment,
+        authoredSlice
       );
     default:
       throw new Error(
@@ -132133,9 +132426,9 @@ function lowerListValue(context, member, expression, base, source, inheritedEnvi
     value: member.listKind === "unordered" ? [] : ids
   };
 }
-function recordRepeatedRow(context, rowId, collection, site) {
-  if (!context.placedStoredRowIds.has(rowId)) {
-    context.placedStoredRowIds.add(rowId);
+function recordRepeatedRow(context, rowId, collection, site, placedIds = context.placedStoredRowIds) {
+  if (!placedIds.has(rowId)) {
+    placedIds.add(rowId);
     return;
   }
   context.loweringFailures.push({
@@ -132177,18 +132470,20 @@ function existingListItemIds(context, member, base) {
     Array.isArray(base.value) ? base.value.filter((entry) => typeof entry === "string") : []
   );
 }
-function lowerDictionaryValue(context, member, expression, base, source, inheritedEnvironment) {
+function lowerDictionaryValue(context, member, expression, base, source, inheritedEnvironment, authoredSlice) {
   if (expression.kind === "litNull")
     return { ...valueFileFields(base), value: null };
   if (expression.kind !== "litDict") {
     throw new Error("Dictionary values require {...}.");
   }
   const baseBody = isObjectRecord2(base.value) ? base.value : {};
+  const existingIds = new Set(Object.values(baseBody));
   const keyEnum = dictionaryKeyEnum(context, member);
   const entryMember = requiredMember(context, member.entryMemberId);
   const environment = valueGenericEnvironment(base, inheritedEnvironment);
   const body = {};
-  for (const entry of expression.entries) {
+  const entrySlices = authoredSlice === void 0 ? [] : topLevelEntrySlices(authoredSlice, "{", "}");
+  for (const [entryIndex, entry] of expression.entries.entries()) {
     const key = lowerDictionaryKey(entry.key, keyEnum, member.name);
     const existingId = baseBody[key];
     const symbolId = sourceValueSymbol(context, entry.value);
@@ -132208,6 +132503,15 @@ function lowerDictionaryValue(context, member, expression, base, source, inherit
         `Dictionary ${member.name}[${JSON.stringify(key)}] has no existing row. New dictionary entries are not implemented by this slice.`
       );
     }
+    if (context.state[`value:${valueId}`] !== void 0 && !existingIds.has(valueId)) {
+      context.storedRowClaims.set(valueId, {
+        code: "invalid-value-move",
+        message: `Value @id(${JSON.stringify(valueId)}) cannot move into another dictionary. Remove @id to create a new value.`,
+        site: referenceSite(source, entry.value)
+      });
+      body[key] = valueId;
+      continue;
+    }
     recordRepeatedRow(
       context,
       valueId,
@@ -132220,7 +132524,8 @@ function lowerDictionaryValue(context, member, expression, base, source, inherit
       entry.value,
       valueId,
       source,
-      environment
+      environment,
+      dictionaryValueSlice(entrySlices[entryIndex])
     );
   }
   return { ...valueFileFields(base), value: body };
@@ -133724,6 +134029,15 @@ function emitValue(context, member, valueId, options) {
   );
   return prefixFor(expression);
 }
+function needsProspectiveValueIdentity(context, valueId, parentId, key) {
+  if (pendingVirtualValueIdentity(valueId) !== null) return true;
+  if (context.storedValueBase === void 0 || isPendingId(valueId))
+    return false;
+  if (typeof parentId !== "string")
+    return !context.storedValueBase.has(valueId);
+  const storedBody = context.storedValueBase.get(parentId)?.value;
+  return !isObjectRecord2(storedBody) || storedBody[key] !== valueId;
+}
 function emitValueBody(context, member, value, visited, targetTyped, environment) {
   const kind = numberField(member, "kind");
   const body = value.value;
@@ -133993,9 +134307,13 @@ function classValueBody(context, member, value, visited, targetTyped, outerEnvir
       `${key} = ${emitValue(context, emittedChildMember, childId, {
         environment,
         definitionSite: !context.symbolsByValueId.has(childId),
-        // Existing slots recover identity from storage. A newly pinned virtual
-        // slot must keep its derived pending identity through repeat lowering.
-        writeIdentity: pendingVirtualValueIdentity(childId) !== null,
+        // New and moved identities must survive repeat lowering against the old placement.
+        writeIdentity: needsProspectiveValueIdentity(
+          context,
+          childId,
+          value.id,
+          key
+        ),
         visited
       })}`
     );
@@ -135273,9 +135591,14 @@ ${entries.flatMap(
           {
             environment,
             definitionSite: !context.symbolsByValueId.has(id2),
-            // Dictionary keys, like class schema keys, recover entry
-            // identity from the owning row. Only list entries need an id.
-            writeIdentity: false,
+            // Existing keys recover identity from their owning row;
+            // new authored identities must survive repeat lowering.
+            writeIdentity: needsProspectiveValueIdentity(
+              context,
+              id2,
+              value.id,
+              key
+            ),
             visited
           }
         )}`,
@@ -137495,55 +137818,6 @@ var init_status_output = __esm({
   }
 });
 
-// src/project-source/identity-rewriter.ts
-function createIdentityRewriter(assignments) {
-  if (assignments.size === 0) return (value) => value;
-  const root = { children: /* @__PURE__ */ new Map() };
-  for (const [source, replacement] of assignments) {
-    let prefix = root;
-    for (let index = 0; index < source.length; index += 1) {
-      const character = source[index];
-      let child2 = prefix.children.get(character);
-      if (child2 === void 0) {
-        child2 = { children: /* @__PURE__ */ new Map() };
-        prefix.children.set(character, child2);
-      }
-      prefix = child2;
-    }
-    prefix.replacement = replacement;
-  }
-  return (value) => {
-    const exact = assignments.get(value);
-    if (exact !== void 0) return exact;
-    const parts = [];
-    let copiedThrough = 0;
-    for (let start = 0; start < value.length; start += 1) {
-      let prefix = root.children.get(value[start]);
-      let replacement;
-      let end = start;
-      for (let index = start; prefix !== void 0; index += 1) {
-        if (prefix.replacement !== void 0) {
-          replacement = prefix.replacement;
-          end = index + 1;
-        }
-        prefix = prefix.children.get(value[index + 1]);
-      }
-      if (replacement === void 0) continue;
-      parts.push(value.slice(copiedThrough, start), replacement);
-      copiedThrough = end;
-      start = end - 1;
-    }
-    if (copiedThrough === 0) return value;
-    parts.push(value.slice(copiedThrough));
-    return parts.join("");
-  };
-}
-var init_identity_rewriter = __esm({
-  "src/project-source/identity-rewriter.ts"() {
-    "use strict";
-  }
-});
-
 // src/project-source/source-layout.ts
 import { readFileSync as readFileSync9 } from "node:fs";
 import { relative as relative4, sep as sep4 } from "node:path";
@@ -164838,7 +165112,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.68.2");
+    console.log("0.68.3");
     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.68.2",
+  "version": "0.68.3",
   "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.68.2 -->
+<!-- reviewed-through-cli: 0.68.3 -->
 
 # Neo Compose CLI
 
@@ -63,8 +63,9 @@ opaque JSON or guessed syntax.
   values, files, or other records. `@system` is reserved for platform-owned
   system records; authoring it can make the record uneditable.
 - Preserve existing `@id` annotations through rename, reorder, and file moves.
-  A new row cannot reuse a stored row's `@id`, including inside a new parent:
-  author the new row without it.
+  A copy must get a new ID. A stored nested class value may keep its UUID-v4
+  when moved between compatible empty fields on existing parents, provided
+  its old parent no longer declares it. See the identity reference for limits.
 - Omit `@id` on new ordinary declarations and nested rows unless a same-push
   structural reference genuinely requires an explicit UUID. A successful push
   assigns the durable IDs and rewrites source.

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

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

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

@@ -57,9 +57,19 @@ keys as quoted IDs when their option has been deleted.
 
 ## Identity rules
 
-Preserve every existing ID through rename, reorder, and file moves. A new row
-cannot reuse a stored row's `@id`, including inside a new parent, and source
-cannot place one stored row in two collection positions. For a new ordinary record, omit
+Preserve every existing ID through rename, reorder, and file moves. A copy
+must get a new ID. A stored nested class value may keep its UUID-v4 when moved
+to an empty, compatible class field on another existing parent. Remove its
+old owning declaration in the same push. Both fields must declare the same
+non-generic class and storage rules. The move must leave exactly one owning
+path to the same root or static binding through ordinary class fields.
+Both ownership paths must use inherited storage and automatic distribution;
+member overrides are not supported for moves. Moving
+projected values, constructor-owned slots, partitioned values, generic
+instances, or unordered-list entries is refused. Moves into newly constructed
+parents are also refused; omit the ID to create a new value there.
+
+For a new ordinary record, omit
 `@id` and let a successful real push assign and insert it. Dry-run and failed pushes
 leave tracked source unchanged.
 
@@ -91,6 +101,11 @@ form, an author may assign a previously unseen UUID-v4 with `@id` to the new
 row and reference it in the same edit. Reusing an existing ID means update, not
 create. The server validates authored new IDs for UUID-v4 shape and uniqueness.
 Prefer generated IDs unless the structural reference needs an ID immediately.
+Dry-run preserves a valid authored UUID-v4 ID on a new nested member or dictionary
+value, including one declared as a local initializer. An unknown malformed member
+value ID is an error at its annotation; remove `@id` to let push assign the ID,
+or supply an unused UUID v4. This does not change the derived identity of a
+root/static binding or an existing projected value.
 
 Do not invent IDs for structural rows whose identities derive from an owner
 role. Do not add a separate root/static initializer ID. A constructor argument