@neocompose/cli 0.21.0 → 0.21.1

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [0.21.1] - 2026-08-03
+
+### Fixed
+
+- `neo pull --reset` reuses typed project indexes while replaying stored
+  constructors instead of rescanning the full value graph for every created
+  row. Large projects such as Neowyn now finish canonical regeneration instead
+  of pinning one CPU core for many minutes.
+- A reset pull now displays progress immediately and updates its phase while
+  downloading files, regenerating sources, and saving pull state.
+
 ## [0.21.0] - 2026-08-02
 
 ### Changed

package/dist/neo.mjs

@@ -42525,7 +42525,7 @@ function cloneDefaultValueForMember(args) {
   return value;
 }
 function findValueInDocument(document, valueId, referenceLocation) {
-  const value = document.values.find((candidate) => candidate.id === valueId);
+  const value = document.valueById?.(valueId) ?? document.values.find((candidate) => candidate.id === valueId);
   if (value === void 0) {
     throw new Error(
       `Default value "${valueId}" in ${referenceLocation} does not exist.`
@@ -42569,9 +42569,7 @@ function isStringRecord(value) {
   return Object.values(value).every((entry) => typeof entry === "string");
 }
 function findMemberInDocument(document, memberId) {
-  const member = document.members.find(
-    (candidate) => candidate.id === memberId
-  );
+  const member = document.memberById?.(memberId) ?? document.members.find((candidate) => candidate.id === memberId);
   if (member === void 0) {
     throw new Error(`Member "${memberId}" does not exist.`);
   }
@@ -54614,12 +54612,7 @@ var init_value_row_owner_members = __esm({
 });
 
 // ../src/database/constructor-argument-ownership.ts
-function requiredConstructorParameterTypes(root, document) {
-  return new MaterializedValueGraphContext(document).constructorParameterTypes(
-    root
-  );
-}
-function createTypedValueNormalizer(rows, document, childrenByContainerId = indexChildrenByContainerId(rows), parameterTypesForRow = (root) => requiredConstructorParameterTypes(root, document), memberById = (memberId) => document.members.find((candidate) => candidate.id === memberId), memberTypeInfo = (member, env) => tryMemberTypeInfo(document, member, env)) {
+function createTypedValueNormalizer(rows, document, childrenByContainerId, parameterTypesForRow, memberById, memberTypeInfo) {
   const visiting = /* @__PURE__ */ new Set();
   const normalizeLiteral = (value) => {
     if (Array.isArray(value)) return value.map(normalizeLiteral);
@@ -54953,20 +54946,22 @@ var init_constructor_argument_ownership = __esm({
       constructorParameterTypes(root) {
         const cached = this.parameterTypesByValueId.get(root.id);
         if (cached !== void 0) return cached;
+        const result = this.resolveConstructorParameterTypes(root);
+        this.parameterTypesByValueId.set(root.id, result);
+        return result;
+      }
+      resolveConstructorParameterTypes(root) {
         const result = /* @__PURE__ */ new Map();
         if (typeof root.classId !== "string") {
-          this.parameterTypesByValueId.set(root.id, result);
           return result;
         }
         const schemaClass2 = this.classesById.get(root.classId);
         const requiredConstructorId2 = schemaClass2?.requiredConstructorId;
         if (requiredConstructorId2 === void 0 || requiredConstructorId2 === null) {
-          this.parameterTypesByValueId.set(root.id, result);
           return result;
         }
         const constructor2 = this.constructorsById.get(requiredConstructorId2);
         if (constructor2 === void 0 || constructor2.classId !== root.classId) {
-          this.parameterTypesByValueId.set(root.id, result);
           return result;
         }
         const env = rowGenericEnvironment(this.document, root);
@@ -54977,7 +54972,6 @@ var init_constructor_argument_ownership = __esm({
           const typeInfo = this.resolveTypeInfo(rawTypeInfo, env);
           if (typeInfo !== null) result.set(parameterId, typeInfo);
         }
-        this.parameterTypesByValueId.set(root.id, result);
         return result;
       }
       constructorEdges(row) {
@@ -55005,6 +54999,51 @@ var init_constructor_argument_ownership = __esm({
       normalizeTypedRow(valueId, typeInfo) {
         return this.normalizer().normalizeTypedRow(valueId, typeInfo);
       }
+      /**
+       * Build a typed normalizer for a small replay graph over this durable graph.
+       *
+       * Constructor replay replaces only the root and rows it creates. Keeping
+       * those rows as a lazy overlay avoids rescanning every durable value for
+       * every reconstructed instance while preserving references from the replay
+       * into independently owned durable rows.
+       */
+      withRowOverrides(overrides) {
+        const overrideChildren = indexChildrenByContainerId(overrides);
+        const rows = {
+          get: (valueId) => overrides.get(valueId) ?? this.valuesById.get(valueId)
+        };
+        const children = {
+          get: (containerId) => {
+            if (overrides.has(containerId)) {
+              return overrideChildren.get(containerId) ?? [];
+            }
+            const replayChildren = overrideChildren.get(containerId);
+            if (replayChildren === void 0) {
+              return this.childrenByContainerId.get(containerId);
+            }
+            const durableChildren = this.childrenByContainerId.get(containerId) ?? [];
+            return [
+              ...durableChildren.filter((child) => !overrides.has(child.id)),
+              ...replayChildren
+            ];
+          }
+        };
+        const parameterTypesByRow = /* @__PURE__ */ new WeakMap();
+        return createTypedValueNormalizer(
+          rows,
+          this.document,
+          children,
+          (row) => {
+            const cached = parameterTypesByRow.get(row);
+            if (cached !== void 0) return cached;
+            const resolved = this.resolveConstructorParameterTypes(row);
+            parameterTypesByRow.set(row, resolved);
+            return resolved;
+          },
+          (memberId) => this.membersById.get(memberId),
+          (member, env) => this.memberTypeInfo(member, env)
+        );
+      }
       ownerForValue(valueId) {
         return this.ownershipFacts().owners.get(valueId);
       }
@@ -56075,15 +56114,22 @@ var init_project2 = __esm({
 function isCatchableNSRuntimeError(error) {
   return error instanceof NSGetterRuntimeError && !(error instanceof NonCatchableNSGetterRuntimeError);
 }
-function makeEvaluatorLookups(members, values) {
+function makeEvaluatorLookups(members, values, options = {}) {
   const attrMap = /* @__PURE__ */ new Map();
   for (const a of members) attrMap.set(a.id, a);
   const valMap = /* @__PURE__ */ new Map();
   for (const v of values) valMap.set(v.id, v);
-  return {
+  const lookups = {
     memberById: (id2) => attrMap.get(id2) ?? null,
     valueById: (id2) => valMap.get(id2) ?? null
   };
+  if (options.includeValueGraphIndexes === true) {
+    return {
+      ...lookups,
+      evaluatorIndexes: buildEvaluatorBaseIndexes(members, values, valMap)
+    };
+  }
+  return lookups;
 }
 function evalMemberById(vm, id2) {
   if (vm.databaseVM?.memberById) return vm.databaseVM.memberById(id2);
@@ -56128,6 +56174,39 @@ function liveListIndexRegistry(ctx) {
   liveListIndexesByProject.set(projectKey, created);
   return created;
 }
+function buildEvaluatorBaseIndexes(members, values, valueById = new Map(
+  values.map((row) => [row.id, row])
+)) {
+  const indexes = {
+    rowByValueReference: /* @__PURE__ */ new WeakMap(),
+    memberByValueId: /* @__PURE__ */ new Map(),
+    parentLinksByChildId: /* @__PURE__ */ new Map(),
+    indexedRowIds: /* @__PURE__ */ new Set(),
+    indexedOverlayValues: /* @__PURE__ */ new Map(),
+    shadowedBaseRowIds: /* @__PURE__ */ new Set(),
+    listIdentityByArray: /* @__PURE__ */ new WeakMap(),
+    declaredListByArray: /* @__PURE__ */ new WeakMap()
+  };
+  const membersByValueId = /* @__PURE__ */ new Map();
+  for (const member of members) {
+    if (typeof member.valueId === "string") {
+      indexes.memberByValueId.set(member.valueId, member);
+      const bucket = membersByValueId.get(member.valueId) ?? [];
+      bucket.push(member);
+      membersByValueId.set(member.valueId, bucket);
+    }
+  }
+  for (const row of values) indexEvaluatorRow(indexes, row);
+  return {
+    rows: values,
+    valueById,
+    rowByValueReference: indexes.rowByValueReference,
+    memberByValueId: indexes.memberByValueId,
+    membersByValueId,
+    parentLinksByChildId: indexes.parentLinksByChildId,
+    indexedRowIds: indexes.indexedRowIds
+  };
+}
 function evaluatorIndexes(ctx) {
   const overlayRevision = ctx.__valueOverlay instanceof LazyValueOverlay ? ctx.__valueOverlay.revision : void 0;
   if (ctx.__indexes !== void 0 && ctx.__indexes.overlayRevision === overlayRevision) {
@@ -56135,22 +56214,38 @@ function evaluatorIndexes(ctx) {
     return ctx.__indexes;
   }
   const liveListIndexes = liveListIndexRegistry(ctx);
+  const base = ctx.vm.databaseVM?.evaluatorIndexes;
   const indexes = {
     rowByValueReference: /* @__PURE__ */ new WeakMap(),
-    memberByValueId: /* @__PURE__ */ new Map(),
+    baseRowByValueReference: base?.rowByValueReference,
+    memberByValueId: base?.memberByValueId ?? /* @__PURE__ */ new Map(),
     parentLinksByChildId: /* @__PURE__ */ new Map(),
+    baseParentLinksByChildId: base?.parentLinksByChildId,
     indexedRowIds: /* @__PURE__ */ new Set(),
+    baseIndexedRowIds: base?.indexedRowIds,
     indexedOverlayValues: /* @__PURE__ */ new Map(),
+    shadowedBaseRowIds: /* @__PURE__ */ new Set(),
     overlayRevision,
     listIdentityByArray: liveListIndexes?.identity ?? /* @__PURE__ */ new WeakMap(),
     declaredListByArray: liveListIndexes?.declared ?? /* @__PURE__ */ new WeakMap()
   };
-  for (const member of ctx.vm.members) {
-    if (typeof member.valueId === "string") {
-      indexes.memberByValueId.set(member.valueId, member);
+  if (base === void 0) {
+    for (const member of ctx.vm.members) {
+      if (typeof member.valueId === "string") {
+        indexes.memberByValueId.set(member.valueId, member);
+      }
+    }
+    for (const row of evaluatorValues(ctx)) indexEvaluatorRow(indexes, row);
+  } else {
+    for (const row of ctx.__runtimeSessionValues?.values() ?? []) {
+      indexes.shadowedBaseRowIds.add(row.id);
+      indexEvaluatorRow(indexes, row, true);
+    }
+    for (const row of ctx.__valueOverlay?.values() ?? []) {
+      indexes.shadowedBaseRowIds.add(row.id);
+      indexEvaluatorRow(indexes, row, true);
     }
   }
-  for (const row of evaluatorValues(ctx)) indexEvaluatorRow(indexes, row);
   syncLazyOverlayReferences(indexes, ctx.__valueOverlay);
   ctx.__indexes = indexes;
   return indexes;
@@ -56165,8 +56260,10 @@ function syncLazyOverlayReferences(indexes, overlay) {
     }
   }
 }
-function indexEvaluatorRow(indexes, row) {
-  if (indexes.indexedRowIds.has(row.id)) return;
+function indexEvaluatorRow(indexes, row, allowBaseShadow = false) {
+  if (indexes.indexedRowIds.has(row.id) || !allowBaseShadow && indexes.baseIndexedRowIds?.has(row.id) === true) {
+    return;
+  }
   indexes.indexedRowIds.add(row.id);
   if (typeof row.value === "object" && row.value !== null) {
     indexes.rowByValueReference.set(row.value, row);
@@ -56191,6 +56288,16 @@ function addEvaluatorParentLink(indexes, childId, parentId, key) {
   links.push({ parentId, key });
   indexes.parentLinksByChildId.set(childId, links);
 }
+function evaluatorParentLinks(indexes, childId) {
+  const unfilteredBase = indexes.baseParentLinksByChildId?.get(childId) ?? [];
+  const base = indexes.shadowedBaseRowIds.size === 0 ? unfilteredBase : unfilteredBase.filter(
+    (link) => !indexes.shadowedBaseRowIds.has(link.parentId)
+  );
+  const local = indexes.parentLinksByChildId.get(childId) ?? [];
+  if (base.length === 0) return local;
+  if (local.length === 0) return base;
+  return [...base, ...local];
+}
 function invalidateEvaluatorIndexes(ctx) {
   if (ctx.__valueOverlay instanceof LazyValueOverlay) {
     ctx.__valueOverlay.markMutated();
@@ -56199,7 +56306,8 @@ function invalidateEvaluatorIndexes(ctx) {
 }
 function trackedRowForValueReference(value, ctx) {
   if (typeof value !== "object" || value === null) return null;
-  return evaluatorIndexes(ctx).rowByValueReference.get(value) ?? null;
+  const indexes = evaluatorIndexes(ctx);
+  return indexes.rowByValueReference.get(value) ?? indexes.baseRowByValueReference?.get(value) ?? null;
 }
 function pushConstructionFrame(ctx, label) {
   const state = ctx.__executionState;
@@ -58360,9 +58468,10 @@ function delegateClosureLexicalThis(closure, ctx) {
     );
   }
   const owners = /* @__PURE__ */ new Map();
-  for (const link of evaluatorIndexes(ctx).parentLinksByChildId.get(
+  for (const link of evaluatorParentLinks(
+    evaluatorIndexes(ctx),
     closureRow.id
-  ) ?? []) {
+  )) {
     const parent = evalValueById(
       ctx.vm,
       link.parentId,
@@ -58515,7 +58624,7 @@ function runtimeGenericEnvForValueRow(row, ctx, visited) {
 }
 function runtimeParentGenericEnv(row, ctx, visited) {
   const result = /* @__PURE__ */ new Map();
-  for (const link of evaluatorIndexes(ctx).parentLinksByChildId.get(row.id) ?? []) {
+  for (const link of evaluatorParentLinks(evaluatorIndexes(ctx), row.id)) {
     const parent = evalValueById(
       ctx.vm,
       link.parentId,
@@ -59251,7 +59360,7 @@ function memberForValueRow(row, ctx, visited = /* @__PURE__ */ new Set()) {
   if (syntheticMemberId !== null) {
     return evalMemberById(ctx.vm, syntheticMemberId);
   }
-  for (const link of indexes.parentLinksByChildId.get(row.id) ?? []) {
+  for (const link of evaluatorParentLinks(indexes, row.id)) {
     const parent = evalValueById(
       ctx.vm,
       link.parentId,
@@ -60359,7 +60468,12 @@ function constructClassValueWithinFrame(descriptor, scope, ctx) {
         members: ctx.vm.members,
         classes: ctx.vm.classes,
         enums: ctx.vm.enums,
-        values: [...evaluatorValues(ctx)],
+        // Declaration defaults only reference durable rows. Supplying the
+        // immutable base plus its indexes avoids copying and linearly scanning
+        // the entire project for every constructor replay.
+        values: ctx.vm.values,
+        memberById: ctx.vm.databaseVM?.memberById,
+        valueById: ctx.vm.databaseVM?.valueById,
         projectFiles: ctx.vm.projectFiles ?? [],
         textureTemplates: ctx.vm.textureTemplates ?? []
       },
@@ -60936,7 +61050,9 @@ function constructDeclaredClassValueWithinFrame(descriptor, record3, info, scope
         members: ctx.vm.members,
         classes: ctx.vm.classes,
         enums: ctx.vm.enums,
-        values: [...evaluatorValues(ctx)],
+        values: ctx.vm.values,
+        memberById: ctx.vm.databaseVM?.memberById,
+        valueById: ctx.vm.databaseVM?.valueById,
         projectFiles: ctx.vm.projectFiles ?? [],
         textureTemplates: ctx.vm.textureTemplates ?? []
       },
@@ -61133,8 +61249,8 @@ function currentOwnedValueAttachments(valueId, ctx) {
       label: `static:${activeStaticRoot.member.id}`
     });
   }
-  for (const member of ctx.vm.members) {
-    if (member.valueId !== valueId) continue;
+  const directlyBoundMembers = ctx.vm.databaseVM?.evaluatorIndexes?.membersByValueId.get(valueId) ?? ctx.vm.members.filter((member) => member.valueId === valueId);
+  for (const member of directlyBoundMembers) {
     const identity2 = member.isStatic ? `static:${member.id}` : `member:${member.id}`;
     add({ identity: identity2, label: identity2 });
   }
@@ -61147,7 +61263,19 @@ function currentOwnedValueAttachments(valueId, ctx) {
       });
     }
   }
-  for (const parent of evaluatorValues(ctx)) {
+  const parentIds = new Set(
+    evaluatorParentLinks(evaluatorIndexes(ctx), valueId).map(
+      (link) => link.parentId
+    )
+  );
+  for (const parentId of parentIds) {
+    const parent = evalValueById(
+      ctx.vm,
+      parentId,
+      ctx.__runtimeSessionValues,
+      ctx.__valueOverlay
+    );
+    if (parent === null) continue;
     if (parent.id === valueId) continue;
     let member = activeStaticBindingRoot(parent.id, ctx)?.member ?? memberForValueRow(parent, ctx);
     if (member !== null) {
@@ -62096,6 +62224,16 @@ var init_evaluateNSGetter = __esm({
       }
       ensureSourceIndexes() {
         if (this.sourceIndexes !== void 0) return this.sourceIndexes;
+        const evaluatorIndexes2 = this.vm.databaseVM?.evaluatorIndexes;
+        if (evaluatorIndexes2 !== void 0) {
+          const indexes2 = {
+            rows: evaluatorIndexes2.rows,
+            byId: evaluatorIndexes2.valueById,
+            byReference: evaluatorIndexes2.rowByValueReference
+          };
+          this.sourceIndexes = indexes2;
+          return indexes2;
+        }
         const rows = [];
         const byId = /* @__PURE__ */ new Map();
         const byReference = /* @__PURE__ */ new WeakMap();
@@ -62118,6 +62256,22 @@ var init_evaluateNSGetter = __esm({
 });
 
 // ../src/view-models/neoscript-evaluator/evaluateInitializer.ts
+function initializerEvaluatorLookups(document) {
+  const key = document;
+  const cached = evaluatorLookupsByDocument.get(key);
+  if (cached !== void 0 && cached.members === document.members && cached.values === document.values) {
+    return cached.lookups;
+  }
+  const lookups = makeEvaluatorLookups(document.members, document.values, {
+    includeValueGraphIndexes: true
+  });
+  evaluatorLookupsByDocument.set(key, {
+    members: document.members,
+    values: document.values,
+    lookups
+  });
+  return lookups;
+}
 function buildInitializerRootValue(document) {
   const rootValue = {};
   const memberById = new Map(
@@ -62154,7 +62308,8 @@ function evaluateMemberInitializer(args) {
       textureTemplates: args.document.textureTemplates,
       constructors: args.document.constructors,
       interfaces: args.document.interfaces,
-      localizedTexts: args.document.localizedTexts
+      localizedTexts: args.document.localizedTexts,
+      databaseVM: initializerEvaluatorLookups(args.document)
     },
     thisValue: null,
     rootValue: buildInitializerRootValue(args.document),
@@ -62178,12 +62333,14 @@ function evaluateMemberInitializer(args) {
     ...constructorArgs === void 0 ? {} : { constructorArgs: structuredClone(constructorArgs) }
   };
 }
+var evaluatorLookupsByDocument;
 var init_evaluateInitializer = __esm({
   "../src/view-models/neoscript-evaluator/evaluateInitializer.ts"() {
     "use strict";
     init_project2();
     init_NSGetterRuntimeError();
     init_evaluateNSGetter();
+    evaluatorLookupsByDocument = /* @__PURE__ */ new WeakMap();
   }
 });
 
@@ -75204,10 +75361,14 @@ function buildValueEmitContext(records2, manifest) {
   return {
     records: records2,
     readDocument,
-    readMaterializedGraph: () => materializedGraph ??= new MaterializedValueGraphContext(
-      readDocument(),
-      memberValueRowMap(values, "stored value graph")
-    ),
+    readMaterializedGraph: () => {
+      if (materializedGraph !== void 0) return materializedGraph;
+      materializedGraph = new MaterializedValueGraphContext(
+        readDocument(),
+        memberValueRowMap(values, "stored value graph")
+      );
+      return materializedGraph;
+    },
     members,
     classes,
     manifestMembers: new Map(
@@ -79010,16 +79171,28 @@ function classValue(context, member, value, visited, targetTyped, outerEnvironme
     visited,
     targetTyped
   );
-  const replayRows = storedConstruction === null || typeof value.id !== "string" || Object.keys(value.value).length === 0 ? null : storedConstructionReplayRows(
+  const replayConstruction = storedConstruction === null ? null : storedConstructorCallSource(
+    context,
+    schemaClass2,
+    value,
+    name,
+    environment,
+    visited,
+    targetTyped,
+    true
+  );
+  const replayRows = replayConstruction === null || typeof value.id !== "string" || Object.keys(value.value).length === 0 ? null : storedConstructionReplayRows(
     context,
     value.id,
-    storedConstruction,
+    replayConstruction,
     member
   );
   const replayRoot = replayRows === null || typeof value.id !== "string" ? void 0 : replayRows.get(value.id);
-  const replayGraph = replayRows === null || typeof value.id !== "string" ? null : new MaterializedValueGraphContext(
-    context.readDocument(),
-    memberValueRowMap(replayRows, `construction replay for ${value.id}`)
+  const replayGraph = replayRows === null || typeof value.id !== "string" ? null : context.readMaterializedGraph().withRowOverrides(
+    memberValueRowMap(
+      replayRows,
+      `construction replay for ${value.id}`
+    )
   );
   const replayBody = isObjectRecord2(replayRoot?.value) ? replayRoot.value : {};
   const order = Array.isArray(schemaClass2.schemaKeyOrder) ? schemaClass2.schemaKeyOrder.filter(
@@ -79092,14 +79265,13 @@ function storedConstructionReplayRows(context, valueId, code, member) {
   if (cached !== void 0) return cached;
   const replay = replayStoredConstructionV4({
     records: context.records,
+    document: context.readDocument(),
     valueId,
     code,
     member
   });
-  const combined = new Map(context.values);
-  for (const [id2, row] of replay) combined.set(id2, row);
-  context.constructionReplays.set(valueId, combined);
-  return combined;
+  context.constructionReplays.set(valueId, replay);
+  return replay;
 }
 function materializedValueSubgraphsEqual(context, currentGraph, replayGraph, currentId, replayId, member, environment) {
   const resolvedMember = resolveGenericValueMember(
@@ -79122,7 +79294,7 @@ function materializedValueSubgraphsEqual(context, currentGraph, replayGraph, cur
     replayGraph.normalizeTypedRow(replayId, typeInfo)
   );
 }
-function storedConstructorCallSource(context, schemaClass2, value, className, environment, visited, targetTyped) {
+function storedConstructorCallSource(context, schemaClass2, value, className, environment, visited, targetTyped, cloneAggregateArguments = false) {
   const constructorArgs = value.constructorArgs;
   if (!isObjectRecord2(constructorArgs)) return null;
   const manifestClass = context.manifestClasses.get(
@@ -79146,7 +79318,8 @@ function storedConstructorCallSource(context, schemaClass2, value, className, en
       argument2.type,
       constructorArgs[key],
       environment,
-      visited
+      visited,
+      cloneAggregateArguments
     )}`;
   });
   return argumentsValue.length === 0 && targetTyped ? "new()" : `new ${className}(${argumentsValue.join(", ")})`;
@@ -79179,7 +79352,7 @@ function storedValueConstructor(context, schemaClass2, constructorArgs) {
   }
   return selected2;
 }
-function storedConstructorArgumentSource(context, type, value, environment, visited) {
+function storedConstructorArgumentSource(context, type, value, environment, visited, cloneAggregateArguments = false) {
   if (value === null) return "null";
   switch (type.kind) {
     case "null":
@@ -79243,6 +79416,9 @@ function storedConstructorArgumentSource(context, type, value, environment, visi
           `Stored Class constructor argument for ${type.classId} is not a value-row reference.`
         );
       }
+      if (cloneAggregateArguments) {
+        return storedAggregateCloneSource(context, type, value, environment);
+      }
       return storedTypedRowSource(context, type, value, environment, visited);
     }
     case "interface":
@@ -79254,6 +79430,9 @@ function storedConstructorArgumentSource(context, type, value, environment, visi
           `Stored ${type.kind} constructor argument is not a value-row reference.`
         );
       }
+      if (cloneAggregateArguments) {
+        return storedAggregateCloneSource(context, type, value, environment);
+      }
       return storedTypedRowSource(context, type, value, environment, visited);
     case "lookup":
       return referenceValue(
@@ -79287,6 +79466,92 @@ function storedConstructorArgumentSource(context, type, value, environment, visi
       );
   }
 }
+function storedAggregateCloneSource(context, type, valueId, environment) {
+  if (!context.values.has(valueId)) {
+    throw new Error(
+      `Stored ${type.kind} constructor argument references missing value row ${valueId}.`
+    );
+  }
+  const typeName = storedSchemaTypeName(context, type, environment, valueId);
+  return `Reference<${typeName}>(id: ${quote4(valueId)}).Clone()`;
+}
+function storedSchemaTypeName(context, type, environment, valueId) {
+  switch (type.kind) {
+    case "unknown":
+      return "object";
+    case "class": {
+      const schemaClass2 = context.manifestClasses.get(type.classId);
+      if (schemaClass2 === void 0) {
+        throw new Error(`Stored Class type ${type.classId} was not pulled.`);
+      }
+      const argumentsValue = schemaClass2.genericParameters.flatMap(
+        (parameter3) => {
+          const argument2 = type.classArguments[parameter3.id];
+          return argument2 === void 0 ? [] : [storedSchemaTypeName(context, argument2, environment)];
+        }
+      );
+      return `${schemaClass2.name}${argumentsValue.length === 0 ? "" : `<${argumentsValue.join(", ")}>`}`;
+    }
+    case "interface": {
+      const row = valueId === void 0 ? void 0 : context.values.get(valueId);
+      if (typeof row?.classId === "string") {
+        const schemaClass2 = context.manifestClasses.get(row.classId);
+        if (schemaClass2 !== void 0) return schemaClass2.name;
+      }
+      const record3 = context.records.get(`interface:${type.interfaceId}`);
+      return stringField3(
+        isObjectRecord2(record3?.data) ? record3.data : {},
+        "name"
+      );
+    }
+    case "generic": {
+      const memberId = environment.get(type.genericParamId);
+      const member = memberId === void 0 ? void 0 : context.manifestMembers.get(memberId);
+      if (member === void 0) {
+        throw new Error(
+          `Stored Generic constructor argument has no concrete binding for ${type.genericParamId}.`
+        );
+      }
+      return manifestMemberTypeName(context, member);
+    }
+    case "list":
+      return `List<${storedSchemaTypeName(context, type.entryType, environment)}>`;
+    case "dictionary": {
+      const keyType = type.keyEnumId === null ? "string" : stringField3(context.enums.get(type.keyEnumId) ?? {}, "name");
+      return `Dictionary<${keyType}, ${storedSchemaTypeName(context, type.entryType, environment)}>`;
+    }
+    case "bool":
+    case "int":
+    case "string":
+    case "float":
+    case "decimal":
+      return type.kind;
+    case "sprite":
+      return "SpriteInfo";
+    case "audio":
+      return "AudioClipInfo";
+    case "vector2":
+      return "Vector2";
+    case "vector2Int":
+      return "Vector2Int";
+    case "vector3":
+      return "Vector3";
+    case "vector3Int":
+      return "Vector3Int";
+    case "color":
+      return "Color";
+    case "enum":
+      return stringField3(context.enums.get(type.enumId) ?? {}, "name");
+    case "lookup":
+      return storedSchemaTypeName(context, type.entryType, environment);
+    case "dialogueLookup":
+      return "Dialogue";
+    case "delegate":
+      return "object";
+    case "null":
+      return "null";
+  }
+}
 function storedTypedRowSource(context, type, valueId, environment, visited) {
   const symbol = context.symbolsByValueId.get(valueId);
   if (symbol !== void 0) return symbol;
@@ -85113,7 +85378,11 @@ import {
 } from "node:fs";
 import { dirname as dirname5, join as join9 } from "node:path";
 async function runPull(workspace, options) {
-  const destructive = options.force || options.reset;
+  if (options.reset) {
+    await runResetPull(workspace);
+    return;
+  }
+  const destructive = options.force;
   const hasBaseline = Object.keys(workspace.state.records).length > 0;
   let localByKey = /* @__PURE__ */ new Map();
   let localStatus = null;
@@ -85160,37 +85429,6 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
     }
   }
   const document = await fetchProjectDocument(workspace);
-  if (options.reset) {
-    const previousRecords = workspace.state.records;
-    const binaries = await pullProjectBinariesV4({
-      workspace,
-      document,
-      previousRecords,
-      destructive: true
-    });
-    const reset = resetWorkspaceToProjectSourcesV4(workspace, document, {
-      regenerateSourceNames: true
-    });
-    for (const [key, state] of binaries.states) {
-      const record3 = workspace.state.records[key];
-      if (record3) record3.projectBinary = state;
-    }
-    try {
-      const convex = await createConvexClient(workspace);
-      const signal = await convex.query(api2.projectExportData.schemaSignal, {
-        projectId: workspace.config.projectId,
-        versionId: workspace.config.versionId
-      });
-      workspace.state.headTransactionHash = signal?.transactionHash ?? null;
-    } catch {
-      workspace.state.headTransactionHash = null;
-    }
-    writeWorkspaceState(workspace.root, workspace.state);
-    console.log(
-      `Pulled ${document.records.size} records \u2014 ${reset.written} file(s) updated \u2014 ${reset.removed} removed.`
-    );
-    return;
-  }
   const plans = /* @__PURE__ */ new Map();
   let mergedCount = 0;
   let conflictCount = 0;
@@ -85313,6 +85551,46 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
     regenerateSourceNames: destructive || options.regenerateSourceNames
   });
 }
+async function runResetPull(workspace) {
+  const progress = spinner("Pulling project snapshot\u2026");
+  try {
+    const document = await fetchProjectDocument(workspace);
+    progress.update("Downloading project files\u2026");
+    const previousRecords = workspace.state.records;
+    const binaries = await pullProjectBinariesV4({
+      workspace,
+      document,
+      previousRecords,
+      destructive: true
+    });
+    progress.update("Regenerating Neo sources\u2026");
+    const reset = resetWorkspaceToProjectSourcesV4(workspace, document, {
+      regenerateSourceNames: true
+    });
+    for (const [key, state] of binaries.states) {
+      const record3 = workspace.state.records[key];
+      if (record3) record3.projectBinary = state;
+    }
+    progress.update("Finalizing pull state\u2026");
+    try {
+      const convex = await createConvexClient(workspace);
+      const signal = await convex.query(api2.projectExportData.schemaSignal, {
+        projectId: workspace.config.projectId,
+        versionId: workspace.config.versionId
+      });
+      workspace.state.headTransactionHash = signal?.transactionHash ?? null;
+    } catch {
+      workspace.state.headTransactionHash = null;
+    }
+    writeWorkspaceState(workspace.root, workspace.state);
+    progress.succeed(
+      `Pulled ${document.records.size} records \u2014 ${reset.written} file(s) updated \u2014 ${reset.removed} removed.`
+    );
+  } catch (error) {
+    progress.fail("Pull failed.");
+    throw error;
+  }
+}
 async function finishFormat4Pull(args) {
   const {
     workspace,

package/package.json

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

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

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