@neocompose/cli 0.22.1 → 0.22.3

package/dist/neo.mjs

@@ -1369,6 +1369,9 @@ function isNeoScriptTypeAssignable(source, target, project) {
   if (source.kind === "typeParameter" && target.kind === "typeParameter") {
     return source.id === target.id;
   }
+  if (source.kind === "typeParameter" && source.constraint !== void 0) {
+    return isNeoScriptTypeAssignable(source.constraint, target, project);
+  }
   if (source.kind === "list" && target.kind === "list") {
     return isNeoScriptTypeAssignable(
       source.elementType,
@@ -29056,7 +29059,7 @@ function memberFromDocument(record3, members, owners, classNames, context) {
   );
   const modifier = memberModifier(overrideOf, isVirtual, isAbstract);
   const defaultValue = defaultValueFromDocument(
-    field("defaultValue", null),
+    overrideOf !== null && !Object.hasOwn(data, "defaultValue") ? null : field("defaultValue", null),
     record3
   );
   const docsText = optionalDocsText(data.docsText, record3, "docsText");
@@ -36759,7 +36762,9 @@ function isMemberGenericBase(value) {
     if (!isSystemMetadata(v.system)) return false;
     if (v.system.kind !== SystemProtectionKind.WorldAuthoring) return false;
   }
-  if (v.defaultValue !== void 0 && v.defaultValue !== null) return false;
+  if (v.defaultValue !== void 0 && v.defaultValue !== null && !isInitValueContent(v.defaultValue)) {
+    return false;
+  }
   if (v.required === true) return false;
   return true;
 }
@@ -38101,10 +38106,20 @@ var init_world_system_classes_generated = __esm({
         docsText: "One value at a frame index inside a segment. It holds until the next row\nyou author, or until the segment's Duration runs out.",
         extendsWorldKind: "animationFrameBase",
         isAbstract: false,
-        constructorProjections: [
+        requiredConstructorId: "system_498d073e-0018-5828-af2b-22b113c31380",
+        constructors: [
           {
-            memberId: "system_b71d1f73-da72-49de-ab9a-911cc9bffa43",
-            parameterName: "value"
+            constructorId: "system_498d073e-0018-5828-af2b-22b113c31380",
+            argumentTypes: [
+              {
+                name: "value",
+                type: 21,
+                required: true,
+                ownerClassId: "system_9c4f3bfb-f0d8-4231-a7e7-9115bab8d5ab",
+                genericParamId: "system_887b11d3-e56a-47ff-8d01-e2fcefb846a1"
+              }
+            ],
+            code: null
           }
         ],
         genericParams: [
@@ -38114,6 +38129,7 @@ var init_world_system_classes_generated = __esm({
           {
             memberId: "system_b71d1f73-da72-49de-ab9a-911cc9bffa43",
             memberKind: "generic",
+            defaultInitializerCode: "value",
             genericParamId: "system_887b11d3-e56a-47ff-8d01-e2fcefb846a1",
             required: false,
             schemaKey: "Value"
@@ -38191,14 +38207,32 @@ var init_world_system_classes_generated = __esm({
         name: "NeoAnimationChildOverride",
         docsText: "What one child looks like while a clip frame holds: which child, and the\nvalues to override on it.",
         isAbstract: false,
-        constructorProjections: [
+        requiredConstructorId: "system_2fefcc00-08ab-5a16-a76a-758beac24ef1",
+        constructors: [
           {
-            memberId: "system_48e66117-43fe-4429-97a8-964165f063ea",
-            parameterName: "selector"
-          },
-          {
-            memberId: "system_819b3743-0c3d-4896-b679-9aeeb73255f4",
-            parameterName: "overrides"
+            constructorId: "system_2fefcc00-08ab-5a16-a76a-758beac24ef1",
+            argumentTypes: [
+              {
+                name: "selector",
+                type: 25,
+                required: true,
+                returnTypeInfo: {
+                  type: 21,
+                  required: true,
+                  ownerClassId: "system_e2e88eba-5335-4a16-9dcf-2c0e1951e8bd",
+                  genericParamId: "system_de23448a-45be-4e3f-8965-072a545e08f0"
+                },
+                argumentTypes: []
+              },
+              {
+                name: "overrides",
+                type: 21,
+                required: true,
+                ownerClassId: "system_e2e88eba-5335-4a16-9dcf-2c0e1951e8bd",
+                genericParamId: "system_de23448a-45be-4e3f-8965-072a545e08f0"
+              }
+            ],
+            code: null
           }
         ],
         genericParams: [
@@ -38212,6 +38246,7 @@ var init_world_system_classes_generated = __esm({
           {
             memberId: "system_48e66117-43fe-4429-97a8-964165f063ea",
             memberKind: "delegate",
+            defaultInitializerCode: "selector",
             returnTypeInfo: {
               type: 21,
               required: true,
@@ -38234,6 +38269,7 @@ var init_world_system_classes_generated = __esm({
           {
             memberId: "system_819b3743-0c3d-4896-b679-9aeeb73255f4",
             memberKind: "generic",
+            defaultInitializerCode: "overrides",
             genericParamId: "system_de23448a-45be-4e3f-8965-072a545e08f0",
             partial: true,
             required: false,
@@ -38247,16 +38283,31 @@ var init_world_system_classes_generated = __esm({
         name: "NeoAnimationTrackBase",
         docsText: "A lane on a clip's timeline: which child it plays against, when it starts,\nwhich way it runs, and which slice of the content to use. Both kinds of\ntrack derive from this, so playing a child clip reversed or cropped is\nsomething you author on the lane rather than pass in when you play it.",
         isAbstract: true,
-        constructorProjections: [
+        requiredConstructorId: "system_8980d09b-0a6d-5461-9615-2f524515b1af",
+        constructors: [
           {
-            memberId: "system_1e877396-1802-474a-9e4d-1df478d4c888",
-            parameterName: "selector"
+            constructorId: "system_8980d09b-0a6d-5461-9615-2f524515b1af",
+            argumentTypes: [
+              {
+                name: "selector",
+                type: 25,
+                required: true,
+                returnTypeInfo: {
+                  type: 7,
+                  required: true,
+                  classId: "system_61b30a92-90dc-4bf8-8503-ee4f6414effc"
+                },
+                argumentTypes: []
+              }
+            ],
+            code: null
           }
         ],
         schemaFields: [
           {
             memberId: "system_1e877396-1802-474a-9e4d-1df478d4c888",
             memberKind: "delegate",
+            defaultInitializerCode: "selector",
             returnTypeInfo: {
               type: 7,
               required: true,
@@ -38330,20 +38381,33 @@ var init_world_system_classes_generated = __esm({
         docsText: "Plays another object's clip on this clip's timeline, looked up by name. The\nlane is as long as the clip it names.",
         extendsWorldKind: "animationTrack",
         isAbstract: false,
-        constructorProjections: [
-          {
-            memberId: "system_1e877396-1802-474a-9e4d-1df478d4c888",
-            parameterName: "selector"
-          },
+        requiredConstructorId: "system_6baa12a7-be86-5ae0-82da-2fed308320a0",
+        constructors: [
           {
-            memberId: "system_2c816624-0281-46d3-9ed5-d20bd43519f4",
-            parameterName: "clipKey"
+            constructorId: "system_6baa12a7-be86-5ae0-82da-2fed308320a0",
+            argumentTypes: [
+              {
+                name: "selector",
+                type: 25,
+                required: true,
+                returnTypeInfo: {
+                  type: 7,
+                  required: true,
+                  classId: "system_61b30a92-90dc-4bf8-8503-ee4f6414effc"
+                },
+                argumentTypes: []
+              },
+              { name: "clipKey", type: 3, required: true }
+            ],
+            code: null,
+            baseArguments: [{ name: "selector", code: "selector" }]
           }
         ],
         schemaFields: [
           {
             memberId: "system_2c816624-0281-46d3-9ed5-d20bd43519f4",
             memberKind: "string",
+            defaultInitializerCode: "clipKey",
             localizable: false,
             required: true,
             schemaKey: "ClipKey"
@@ -38357,10 +38421,26 @@ var init_world_system_classes_generated = __esm({
         docsText: "Plays a sequence of values onto one member of one child, on the owning\nclip's clock. Where a child track hands off to another clip, this lane is a\nleaf: it writes one value per frame to the member its subclass targets.\n\nDerive from it with the child type you author against, so that a Segment\ngetter can reach that child's own members.",
         extendsWorldKind: "animationTrack",
         isAbstract: true,
-        constructorProjections: [
+        requiredConstructorId: "system_1e7f8826-5392-5b4c-8cc3-6052d20e5280",
+        constructors: [
           {
-            memberId: "system_b29e7ab9-0b8e-4399-84c1-1203070b75dd",
-            parameterName: "selector"
+            constructorId: "system_1e7f8826-5392-5b4c-8cc3-6052d20e5280",
+            argumentTypes: [
+              {
+                name: "selector",
+                type: 25,
+                required: true,
+                returnTypeInfo: {
+                  type: 21,
+                  required: true,
+                  ownerClassId: "system_fd551dd8-6e6b-4044-9f32-7445ab344200",
+                  genericParamId: "system_d4fe9f71-d9d9-4baf-bc52-8de16933b655"
+                },
+                argumentTypes: []
+              }
+            ],
+            code: null,
+            baseArguments: [{ name: "selector", code: "selector" }]
           }
         ],
         genericParams: [
@@ -38376,6 +38456,7 @@ var init_world_system_classes_generated = __esm({
             memberId: "system_b29e7ab9-0b8e-4399-84c1-1203070b75dd",
             memberKind: "delegate",
             extendsMemberId: "system_1e877396-1802-474a-9e4d-1df478d4c888",
+            defaultInitializerCode: "selector",
             docsText: "The child this lane plays against, typed as the child class you derived with, so a Segment getter can read that child's own members.",
             returnTypeInfo: {
               type: 21,
@@ -38417,6 +38498,28 @@ var init_world_system_classes_generated = __esm({
         docsText: "Plays a sprite segment onto a sprite child's Sprite member \u2014 the lane that\nanimates a sprite over time. Derive from it to say where the segment comes\nfrom; Segment is left for you to fill in, so every lane that plays is one of\nyour own classes.",
         extendsWorldKind: "animationSegmentTrack",
         isAbstract: true,
+        requiredConstructorId: "system_9a3f52ca-872a-50a5-aad9-e9a040f40802",
+        constructors: [
+          {
+            constructorId: "system_9a3f52ca-872a-50a5-aad9-e9a040f40802",
+            argumentTypes: [
+              {
+                name: "selector",
+                type: 25,
+                required: true,
+                returnTypeInfo: {
+                  type: 21,
+                  required: true,
+                  ownerClassId: "system_24b70585-0798-49ad-b650-4c118bac1eb1",
+                  genericParamId: "system_4de90637-6a3b-4bba-95ef-2ff9dfb05268"
+                },
+                argumentTypes: []
+              }
+            ],
+            code: null,
+            baseArguments: [{ name: "selector", code: "selector" }]
+          }
+        ],
         extendsGenericBindings: {
           "system_d4fe9f71-d9d9-4baf-bc52-8de16933b655": {
             kind: "generic",
@@ -47886,20 +47989,60 @@ function buildDeclaredConstructorIndex(analysis) {
     if (declaration.constructors.length === 0) continue;
     byClassName.set(declaration.name, declaration.constructors);
   }
-  return { byClassName, requiredByClassName };
+  return {
+    byClassName,
+    requiredByClassName,
+    persistedByClassName: /* @__PURE__ */ new Map(),
+    persistedRequiredByClassName: /* @__PURE__ */ new Map()
+  };
+}
+function withPersistedConstructorSignatures(index, classes, constructors) {
+  const byId = new Map(constructors.map((entry) => [entry.id, entry]));
+  const persistedByClassName = /* @__PURE__ */ new Map();
+  const persistedRequiredByClassName = /* @__PURE__ */ new Map();
+  for (const schemaClass2 of classes) {
+    if (schemaClass2.requiredConstructorId !== void 0) {
+      const required2 = byId.get(schemaClass2.requiredConstructorId);
+      if (required2 !== void 0) {
+        persistedRequiredByClassName.set(
+          schemaClass2.name,
+          required2.arguments.map((argument2) => argument2.name)
+        );
+      }
+    }
+    const overloads = (schemaClass2.constructorIds ?? []).flatMap((id2) => {
+      const constructor2 = byId.get(id2);
+      return constructor2 === void 0 ? [] : [constructor2.arguments.map((argument2) => argument2.name)];
+    });
+    if (overloads.length > 0) {
+      persistedByClassName.set(schemaClass2.name, overloads);
+    }
+  }
+  return {
+    ...index,
+    persistedByClassName,
+    persistedRequiredByClassName
+  };
 }
 function declaresConstructors(index, className) {
   if (className === null) return false;
   if (index.requiredByClassName.has(className)) return true;
-  return (index.byClassName.get(className)?.length ?? 0) > 0;
+  if (index.persistedRequiredByClassName.has(className)) return true;
+  return (index.byClassName.get(className)?.length ?? 0) > 0 || (index.persistedByClassName.get(className)?.length ?? 0) > 0;
 }
 function declaresParameterlessConstructor(index, className) {
   if (className === null) return false;
   const required2 = index.requiredByClassName.get(className);
   if (required2 !== void 0 && required2.parameters.length === 0) return true;
+  const persistedRequired = index.persistedRequiredByClassName.get(className);
+  if (persistedRequired !== void 0 && persistedRequired.length === 0) {
+    return true;
+  }
   const declared = index.byClassName.get(className);
-  if (declared === void 0) return false;
-  return declared.some((entry) => entry.parameters.length === 0);
+  if (declared?.some((entry) => entry.parameters.length === 0) === true) {
+    return true;
+  }
+  return index.persistedByClassName.get(className)?.some((parameters) => parameters.length === 0) ?? false;
 }
 function initializerRequiresEvaluation(index, expression, targetClassName, runtimeIdentifiers = /* @__PURE__ */ new Set()) {
   if (expression.kind === "annotated") {
@@ -47925,8 +48068,10 @@ function initializerRequiresEvaluation(index, expression, targetClassName, runti
 function requiredConstructorParameterNames(index, className) {
   if (className === null) return /* @__PURE__ */ new Set();
   const required2 = index.requiredByClassName.get(className);
-  if (required2 === void 0) return /* @__PURE__ */ new Set();
-  return new Set(required2.parameters.map((parameter3) => parameter3.name));
+  if (required2 !== void 0) {
+    return new Set(required2.parameters.map((parameter3) => parameter3.name));
+  }
+  return new Set(index.persistedRequiredByClassName.get(className) ?? []);
 }
 function expressionReadsRuntimeIdentifier(expression, runtimeIdentifiers) {
   if (runtimeIdentifiers.size === 0) return false;
@@ -48019,7 +48164,9 @@ var init_declared_constructors2 = __esm({
     init_src();
     EMPTY_DECLARED_CONSTRUCTOR_INDEX = {
       byClassName: /* @__PURE__ */ new Map(),
-      requiredByClassName: /* @__PURE__ */ new Map()
+      requiredByClassName: /* @__PURE__ */ new Map(),
+      persistedByClassName: /* @__PURE__ */ new Map(),
+      persistedRequiredByClassName: /* @__PURE__ */ new Map()
     };
   }
 });
@@ -50961,7 +51108,14 @@ function classToLanguageType(schemaClass2, context) {
         type: {
           kind: "typeParameter",
           id: parameter3.id,
-          name: parameter3.name
+          name: parameter3.name,
+          ownerClassId: schemaClass2.id,
+          ...parameter3.constraint === void 0 || parameter3.constraint === null ? {} : {
+            constraint: namedType(
+              parameter3.constraint.kind === "class" ? parameter3.constraint.classId : parameter3.constraint.enumId,
+              true
+            )
+          }
         },
         location: virtualIdentifierLocation(
           context,
@@ -51788,10 +51942,20 @@ function toLanguageType(type, context, genericEnvironment) {
       const name = owner?.genericParams?.find(
         (parameter3) => parameter3.id === effectiveParamId
       )?.name ?? effectiveParamId;
+      const declaration = owner?.genericParams?.find(
+        (parameter3) => parameter3.id === effectiveParamId
+      );
       return {
         kind: "typeParameter",
         id: effectiveParamId,
         name,
+        ...owner === void 0 ? {} : { ownerClassId: owner.id },
+        ...declaration?.constraint === void 0 || declaration.constraint === null ? {} : {
+          constraint: namedType(
+            declaration.constraint.kind === "class" ? declaration.constraint.classId : declaration.constraint.enumId,
+            true
+          )
+        },
         nullable: !required2
       };
     }
@@ -52432,7 +52596,7 @@ function compileMemberInitializerBody(args) {
     );
   }
   const members = replaceMember(args.members, args.member);
-  const returnTypeInfo = resolveMemberDeclaredTypeInfo(args.member, members);
+  const returnTypeInfo = resolveMemberDeclaredTypeInfo(args.member, members) ?? initializerGenericTypeInfo(args.member, args.thisClass);
   if (returnTypeInfo === null) {
     throw new Error(
       `Member "${args.member.name}" has an initializer but no resolvable declared type.`
@@ -52469,6 +52633,19 @@ function compileMemberInitializerBody(args) {
   }
   Object.assign(defaultValue.init, { compiled });
 }
+function initializerGenericTypeInfo(member, ownerClass) {
+  if (!isMemberGenericBase(member) || ownerClass === null) return null;
+  const declaration = ownerClass.genericParams?.find(
+    (parameter3) => parameter3.id === member.genericParamId
+  );
+  if (declaration === void 0) return null;
+  return {
+    type: 21 /* Generic */,
+    required: member.required,
+    ownerClassId: ownerClass.id,
+    genericParamId: declaration.id
+  };
+}
 function compileValueRowInitializerBody(args) {
   const container = args.valueRow;
   if (!isInitValueContent(container)) return;
@@ -52644,6 +52821,11 @@ function compileConstructorBaseArguments(args, owner) {
           `Constructor "${args.constructor.id}" binds base argument "${baseArgument.name}", which base constructor "${baseConstructor.id}" does not declare.`
         );
       }
+      const returnTypeInfo = substituteConstructorBaseType(
+        parameter3,
+        owner,
+        args
+      );
       return compileUnit2(
         "getter",
         () => compileNSInitializer(baseArgument.code, {
@@ -52655,7 +52837,7 @@ function compileConstructorBaseArguments(args, owner) {
           interfaces: [...args.interfaces ?? []],
           constructors: args.constructors,
           ...args.compilationProject === void 0 ? {} : { compilationProject: args.compilationProject },
-          returnTypeInfo: parameter3,
+          returnTypeInfo,
           argumentTypes,
           initializerName: `${owner.name} base argument ${baseArgument.name}`
         })
@@ -52664,6 +52846,65 @@ function compileConstructorBaseArguments(args, owner) {
   );
   Object.assign(args.constructor, { compiledBaseArguments });
 }
+function substituteConstructorBaseType(typeInfo, owner, args) {
+  if (typeInfo.type === 21 /* Generic */) {
+    const binding = resolveGenericEnv(owner.id, args.classes).get(
+      typeInfo.genericParamId
+    );
+    if (binding === void 0) return typeInfo;
+    if (binding.kind === "unbound") {
+      return {
+        ...typeInfo,
+        ownerClassId: owner.id,
+        genericParamId: binding.paramId
+      };
+    }
+    const member = args.members.find(
+      (candidate) => candidate.id === binding.memberId
+    );
+    if (member === void 0) {
+      throw new Error(
+        `Constructor "${args.constructor.id}" resolves generic parameter "${typeInfo.genericParamId}" to missing member "${binding.memberId}".`
+      );
+    }
+    return resolveMemberDeclaredTypeInfo(member, args.members) ?? typeInfo;
+  }
+  if (typeInfo.type === 25 /* NSDelegate */) {
+    return {
+      ...typeInfo,
+      returnTypeInfo: substituteConstructorBaseType(
+        typeInfo.returnTypeInfo,
+        owner,
+        args
+      ),
+      argumentTypes: typeInfo.argumentTypes.map(
+        (argument2) => substituteConstructorBaseType(argument2, owner, args)
+      )
+    };
+  }
+  if (typeInfo.type === 6 /* List */ || typeInfo.type === 5 /* Dictionary */ || typeInfo.type === 9 /* Lookup */) {
+    return {
+      ...typeInfo,
+      entryTypeInfo: substituteConstructorBaseType(
+        typeInfo.entryTypeInfo,
+        owner,
+        args
+      )
+    };
+  }
+  if (typeInfo.type !== 7 /* Class */ || typeInfo.typeArguments === void 0) {
+    return typeInfo;
+  }
+  return {
+    ...typeInfo,
+    typeArguments: Object.fromEntries(
+      Object.entries(typeInfo.typeArguments).map(([parameterId, argument2]) => [
+        parameterId,
+        substituteConstructorBaseType(argument2, owner, args)
+      ])
+    )
+  };
+}
 function compileConstructorBaseInitializerFields(args, owner) {
   const fields = args.constructor.baseInitializerFields ?? [];
   if (fields.length === 0) {
@@ -52983,6 +53224,7 @@ var init_compile_ns_property = __esm({
     "use strict";
     init_members();
     init_inheritance();
+    init_generics();
     init_neoscript();
     init_core();
     init_lookup_declared_type();
@@ -53196,6 +53438,19 @@ var init_value_row_owner_members = __esm({
 });
 
 // ../src/database/constructor-argument-ownership.ts
+function constructorActionParameterId(constructor2, index) {
+  const action = constructor2.action;
+  if (action !== null && typeof action === "object") {
+    const parameters = action.parameters;
+    if (Array.isArray(parameters)) {
+      const parameter3 = parameters[index + 2];
+      if (parameter3 !== null && typeof parameter3 === "object" && typeof parameter3.id === "string") {
+        return parameter3.id;
+      }
+    }
+  }
+  return `__arg_${index}__`;
+}
 function createTypedValueNormalizer(rows, document, childrenByContainerId, parameterTypesForRow, memberById, memberTypeInfo) {
   const visiting = /* @__PURE__ */ new Set();
   const normalizeLiteral = (value) => {
@@ -53550,7 +53805,7 @@ var init_constructor_argument_ownership = __esm({
         }
         const env = rowGenericEnvironment(this.document, root);
         for (let index = 0; index < constructor2.argumentTypes.length; index += 1) {
-          const parameterId = constructor2.action.parameters[index + 2]?.id;
+          const parameterId = constructorActionParameterId(constructor2, index);
           const rawTypeInfo = constructor2.argumentTypes[index];
           if (parameterId === void 0 || rawTypeInfo === void 0) continue;
           const typeInfo = this.resolveTypeInfo(rawTypeInfo, env);
@@ -57590,6 +57845,8 @@ function runtimeTypeCheck(value, checkType, ctx, seenCollections = /* @__PURE__
       return isDecimalString(value);
     case 3 /* String */:
       return typeof value === "string";
+    case 25 /* NSDelegate */:
+      return isNSDelegateClosureValue(value) || isMemberDelegateTarget(value);
     case 11 /* Sprite */:
       return isRuntimeSpriteValue(value);
     case 12 /* Audio */:
@@ -59079,7 +59336,15 @@ function constructClassValueWithinFrame(descriptor, scope, ctx) {
       // A class with no declared constructors can still carry init-backed
       // member defaults (P43 §2, `string Foo = StaticFunc("bar")`), so the
       // schema-derived path evaluates them exactly as the declared one does.
-      initEvaluator: constructionInitEvaluator(ctx, createdValues),
+      initEvaluator: constructionInitEvaluator(
+        ctx,
+        createdValues,
+        {
+          valuesByClassId: /* @__PURE__ */ new Map(),
+          missingScopeReason: "no-constructor"
+        },
+        classId
+      ),
       constructorRoot: {
         providedSchemaKeys: new Set(
           supplied.filter((entry) => entry.value !== null).map((entry) => entry.validated.schemaKey)
@@ -59330,15 +59595,17 @@ function runDeclaredConstructorChain(args) {
   args.visitedConstructorIds.add(record3.id);
   const baseRecord = resolveBaseConstructorRecord(record3, ctx);
   if (baseRecord !== null) {
+    const preparedBaseArguments = args.preparedArgumentScopes.valuesByClassId.get(baseRecord.classId);
     runDeclaredConstructorChain({
       record: baseRecord,
-      argumentValues: evaluateBaseConstructorArguments(
+      argumentValues: preparedBaseArguments ?? evaluateBaseConstructorArguments(
         record3,
         baseRecord,
         args.argumentValues,
         args.thisValue,
         ctx
       ),
+      preparedArgumentScopes: args.preparedArgumentScopes,
       thisValue: args.thisValue,
       ctx,
       visitedConstructorIds: args.visitedConstructorIds,
@@ -59443,13 +59710,165 @@ function evaluateBaseInitializerFields(args) {
     return { validated, value };
   });
 }
-function constructionInitEvaluator(ctx, createdValues, argumentValues = []) {
-  return (member, init) => evaluateInitializerInContext(
-    init,
-    member,
-    ctx,
-    createdValues,
-    argumentValues
+function constructionInitEvaluator(ctx, createdValues, argumentScopes, constructedClassId) {
+  const indexes = constructorInitializerIndexes(ctx);
+  const inheritanceChain = resolveInheritanceChain(
+    constructedClassId,
+    ctx.vm.classes
+  );
+  const owningClassId = (memberId) => {
+    const visited = /* @__PURE__ */ new Set();
+    let currentId = memberId;
+    while (currentId !== void 0 && !visited.has(currentId)) {
+      visited.add(currentId);
+      const declaringClassIds = indexes.declaringClassIdsByMemberId.get(currentId);
+      const owner = inheritanceChain.find(
+        (schemaClass2) => declaringClassIds?.has(schemaClass2.id)
+      );
+      if (owner !== void 0) return owner.id;
+      currentId = indexes.containerMemberIdByEntryId.get(currentId) ?? indexes.memberById.get(currentId)?.extendsMemberId;
+    }
+    return null;
+  };
+  return (member, init) => {
+    if (init.compiled === void 0) {
+      return evaluateInitializerInContext(init, member, ctx, createdValues);
+    }
+    const memberId = Reflect.get(member, "id");
+    const scopeMemberId = indexes.initializerScopeMemberIds.get(init) ?? (typeof memberId === "string" ? memberId : "");
+    const ownerClassId = owningClassId(scopeMemberId);
+    const expectedArgumentCount = init.compiled?.parameters.slice(2).length;
+    if (ownerClassId === null) {
+      if (expectedArgumentCount !== void 0 && expectedArgumentCount > 0) {
+        throw new NSGetterRuntimeError(
+          `Member initializer '${member.name}' has ${expectedArgumentCount} constructor parameter(s), but its declaring class scope could not be resolved.`
+        );
+      }
+      return evaluateInitializerInContext(init, member, ctx, createdValues);
+    }
+    const scopedArguments = argumentScopes.valuesByClassId.get(ownerClassId);
+    if (scopedArguments === void 0) {
+      if (expectedArgumentCount === 0) {
+        return evaluateInitializerInContext(init, member, ctx, createdValues);
+      }
+      if (argumentScopes.missingScopeReason === "no-constructor") {
+        throw new NSGetterRuntimeError(
+          `Member initializer '${member.name}' on '${ownerClassId}' cannot read constructor parameters because schema-derived construction invoked no constructor.`
+        );
+      }
+      throw new NSGetterRuntimeError(
+        `Member initializer '${member.name}' on '${ownerClassId}' cannot read constructor parameters because its ': base(...)' arguments depend on initialized 'this'.`
+      );
+    }
+    if (expectedArgumentCount !== void 0 && expectedArgumentCount !== scopedArguments.length) {
+      throw new NSGetterRuntimeError(
+        `Member initializer '${member.name}' on '${ownerClassId}' expected ${expectedArgumentCount} constructor argument(s), got ${scopedArguments.length}.`
+      );
+    }
+    return evaluateInitializerInContext(
+      init,
+      member,
+      ctx,
+      createdValues,
+      scopedArguments
+    );
+  };
+}
+function constructorInitializerIndexes(ctx) {
+  if (ctx.__constructorInitializerIndexes !== void 0) {
+    return ctx.__constructorInitializerIndexes;
+  }
+  const initializerScopeMemberIds = /* @__PURE__ */ new WeakMap();
+  const initializerByValueId = /* @__PURE__ */ new Map();
+  for (const row of ctx.vm.values) {
+    const initializer = Reflect.get(row, "init");
+    if (initializer !== void 0)
+      initializerByValueId.set(row.id, initializer);
+  }
+  for (const member of ctx.vm.members) {
+    const defaultValue = member.defaultValue;
+    if (isInitValueContent(defaultValue)) {
+      initializerScopeMemberIds.set(defaultValue.init, member.id);
+      continue;
+    }
+    if (!isLiteralValueContent(defaultValue)) continue;
+    const value = defaultValue.value;
+    const valueIds = Array.isArray(value) ? value : typeof value === "object" && value !== null ? Object.values(value) : [];
+    for (const valueId of valueIds) {
+      if (typeof valueId !== "string") continue;
+      const initializer = initializerByValueId.get(valueId);
+      if (initializer !== void 0) {
+        initializerScopeMemberIds.set(initializer, member.id);
+      }
+    }
+  }
+  const declaringClassIdsByMemberId = /* @__PURE__ */ new Map();
+  for (const schemaClass2 of ctx.vm.classes) {
+    for (const memberId of Object.values(schemaClass2.schema)) {
+      const owners = declaringClassIdsByMemberId.get(memberId) ?? /* @__PURE__ */ new Set();
+      owners.add(schemaClass2.id);
+      declaringClassIdsByMemberId.set(memberId, owners);
+    }
+  }
+  const memberById = new Map(
+    ctx.vm.members.map((member) => [member.id, member])
+  );
+  const containerMemberIdByEntryId = /* @__PURE__ */ new Map();
+  for (const member of ctx.vm.members) {
+    if (isMemberList(member) || isMemberDictionary(member)) {
+      containerMemberIdByEntryId.set(member.entryMemberId, member.id);
+    }
+  }
+  const built = {
+    initializerScopeMemberIds,
+    declaringClassIdsByMemberId,
+    memberById,
+    containerMemberIdByEntryId
+  };
+  ctx.__constructorInitializerIndexes = built;
+  return built;
+}
+function prepareConstructorArgumentScopes(record3, argumentValues, ctx) {
+  const values = /* @__PURE__ */ new Map();
+  let current = record3;
+  let currentValues = argumentValues;
+  while (current !== null) {
+    values.set(current.classId, currentValues);
+    const base = resolveBaseConstructorRecord(current, ctx);
+    if (base === null) break;
+    if (baseArgumentGettersReferenceThis(current)) break;
+    currentValues = evaluateBaseConstructorArguments(
+      current,
+      base,
+      currentValues,
+      null,
+      ctx
+    );
+    current = base;
+  }
+  return {
+    valuesByClassId: values,
+    missingScopeReason: record3 === null ? "no-constructor" : "base-arguments-depend-on-this"
+  };
+}
+function baseArgumentGettersReferenceThis(record3) {
+  return (record3.compiledBaseArguments ?? []).some((getter) => {
+    const thisParameter = getter.parameters[0];
+    return thisParameter !== void 0 && runtimeValueReferencesVariable(getter.instructions, thisParameter.id);
+  });
+}
+function runtimeValueReferencesVariable(value, variableId, visited = /* @__PURE__ */ new WeakSet()) {
+  if (typeof value !== "object" || value === null) return false;
+  if (visited.has(value)) return false;
+  visited.add(value);
+  if (Reflect.get(value, "type") === "variable" /* variable */ && Reflect.get(value, "variableId") === variableId) {
+    return true;
+  }
+  const children = Object.values(Object.getOwnPropertyDescriptors(value)).filter(
+    (descriptor) => "value" in descriptor
+  ).map((descriptor) => descriptor.value);
+  return children.some(
+    (child) => runtimeValueReferencesVariable(child, variableId, visited)
   );
 }
 function evaluateInitializerInContext(init, member, ctx, createdValues, argumentValues = []) {
@@ -59636,6 +60055,11 @@ function constructDeclaredClassValueWithinFrame(descriptor, record3, info, scope
   const schemaClass2 = descriptor.schemaClass;
   const classId = schemaClass2.id;
   const argumentValues = record3 === null ? [] : evaluateDeclaredConstructorArguments(info, record3, scope, ctx);
+  const preparedArgumentScopes = prepareConstructorArgumentScopes(
+    record3,
+    argumentValues,
+    ctx
+  );
   const createdValues = [];
   const storageKeyDeclarations = /* @__PURE__ */ new Map();
   let root;
@@ -59660,7 +60084,8 @@ function constructDeclaredClassValueWithinFrame(descriptor, record3, info, scope
       initEvaluator: constructionInitEvaluator(
         ctx,
         createdValues,
-        argumentValues
+        preparedArgumentScopes,
+        classId
       ),
       constructorRoot: {
         providedSchemaKeys: new Set(
@@ -59721,6 +60146,7 @@ function constructDeclaredClassValueWithinFrame(descriptor, record3, info, scope
     runDeclaredConstructorChain({
       record: record3,
       argumentValues,
+      preparedArgumentScopes,
       thisValue: root.value,
       ctx,
       visitedConstructorIds: /* @__PURE__ */ new Set(),
@@ -60906,6 +61332,7 @@ function evaluateMemberInitializer(args) {
       constructors: args.document.constructors,
       interfaces: args.document.interfaces,
       localizedTexts: args.document.localizedTexts,
+      localizationConfig: args.document.localizationConfig,
       databaseVM: initializerEvaluatorLookups(args.document)
     },
     thisValue: null,
@@ -61070,6 +61497,14 @@ function isNeoClassConstructorBase(value) {
   }
   return v.compiledBaseInitializerFields === void 0 || v.compiledBaseInitializerFields === null;
 }
+function isUncompiledNeoClassConstructor(value) {
+  if (!isNeoClassConstructorBase(value)) return false;
+  const v = value;
+  if (typeof v.id !== "string" || v.id.length === 0) return false;
+  if (typeof v.projectId !== "string" || v.projectId.length === 0) return false;
+  if (!isEpochMillis(v.createdAt)) return false;
+  return isEpochMillis(v.updatedAt);
+}
 function hasValidConstructorAction(action, argumentTypes) {
   if (!isNSFunctionWithReturnType(action)) return false;
   if (action.typeInfo.type !== 0 /* Null */) return false;
@@ -62461,7 +62896,7 @@ function readProjectDocument(value, options = {}) {
     constructors: readOptionalArrayField(
       value,
       "constructors",
-      isNeoClassConstructor
+      options.constructors === "authored-or-compiled" ? (candidate) => isNeoClassConstructor(candidate) || isUncompiledNeoClassConstructor(candidate) : isNeoClassConstructor
     ),
     internalRecordRelations: readOptionalArrayField(
       value,
@@ -68291,6 +68726,7 @@ function collectNeoScriptRecompileTargets(args) {
   if (args.forceRecompile === true) return completeTargets(args.postDocument);
   const explicit = explicitTargetIds(args.changes);
   const { impactedIds, impactedTypeNames, constructedClassIds } = collectChangedContractIds(args);
+  for (const id2 of args.additionalImpactedIds ?? []) impactedIds.add(id2);
   includeDerivedConstructionContracts(
     constructedClassIds,
     args.postDocument.classes
@@ -68316,13 +68752,21 @@ function collectNeoScriptRecompileTargets(args) {
     }
   }
   const constructorOwnerById = constructorOwners(args.postDocument);
+  const impactedSourceNames = collectImpactedSourceNames({
+    currentDocument: args.currentDocument,
+    postDocument: args.postDocument,
+    impactedIds,
+    impactedTypeNames,
+    constructedClassIds
+  });
   const memberIds = new Set(explicit.memberIds);
   for (const member of args.postDocument.members) {
     if (recordDependsOnChangedContract(
       member,
       impactedIds,
       impactedTypeNames,
-      constructedClassIds
+      constructedClassIds,
+      impactedSourceNames
     )) {
       memberIds.add(member.id);
     }
@@ -68333,7 +68777,8 @@ function collectNeoScriptRecompileTargets(args) {
     explicit.valueIds,
     impactedIds,
     impactedTypeNames,
-    constructedClassIds
+    constructedClassIds,
+    impactedSourceNames
   );
   if (impactedIds.size > 0 && postValues.length > 0) {
     const ownerByValueId = resolveOwnerMembersForValues(
@@ -68356,6 +68801,7 @@ function collectNeoScriptRecompileTargets(args) {
       impactedIds,
       impactedTypeNames,
       constructedClassIds,
+      impactedSourceNames,
       (record3) => constructorOwnerById.get(record3.id) ?? null
     ),
     migrationIds: selectedRecordIds(
@@ -68363,21 +68809,24 @@ function collectNeoScriptRecompileTargets(args) {
       explicit.migrationIds,
       impactedIds,
       impactedTypeNames,
-      constructedClassIds
+      constructedClassIds,
+      impactedSourceNames
     ),
     dialogueNodeIds: selectedRecordIds(
       args.postDocument.dialogueNodes ?? [],
       explicit.dialogueNodeIds,
       impactedIds,
       impactedTypeNames,
-      constructedClassIds
+      constructedClassIds,
+      impactedSourceNames
     ),
     dialogueGroupIds: selectedRecordIds(
       args.postDocument.dialogueGroups ?? [],
       explicit.dialogueGroupIds,
       impactedIds,
       impactedTypeNames,
-      constructedClassIds
+      constructedClassIds,
+      impactedSourceNames
     ),
     valueIds
   };
@@ -68746,7 +69195,7 @@ function explicitTargetIds(changes) {
   }
   return result;
 }
-function selectedRecordIds(records2, explicitIds, impactedIds, impactedTypeNames, constructedClassIds, ownerId = () => null) {
+function selectedRecordIds(records2, explicitIds, impactedIds, impactedTypeNames, constructedClassIds, impactedSourceNames, ownerId = () => null) {
   const selected2 = new Set(explicitIds);
   for (const record3 of records2) {
     const owner = ownerId(record3);
@@ -68754,14 +69203,17 @@ function selectedRecordIds(records2, explicitIds, impactedIds, impactedTypeNames
       record3,
       impactedIds,
       impactedTypeNames,
-      constructedClassIds
+      constructedClassIds,
+      impactedSourceNames
     )) {
       selected2.add(record3.id);
     }
   }
   return selected2;
 }
-function recordDependsOnChangedContract(record3, impactedIds, impactedTypeNames, constructedClassIds) {
+function recordDependsOnChangedContract(record3, impactedIds, impactedTypeNames, constructedClassIds, impactedSourceNames) {
+  const recordId = isObjectRecord3(record3) ? record3.id : void 0;
+  if (typeof recordId === "string" && impactedIds.has(recordId)) return true;
   if (intersects(collectCompilerReferenceIds(record3), impactedIds)) return true;
   if (intersects(collectCompilerReferenceNames(record3), impactedTypeNames)) {
     return true;
@@ -68769,7 +69221,109 @@ function recordDependsOnChangedContract(record3, impactedIds, impactedTypeNames,
   if (intersects(collectConstructedClassIds(record3), constructedClassIds)) {
     return true;
   }
-  return (impactedIds.size > 0 || impactedTypeNames.size > 0) && containsAuthoredNeoScriptSource(record3) && !containsCompiledNeoScriptBody(record3);
+  if (impactedIds.size === 0 && impactedTypeNames.size === 0) return false;
+  if (!containsAuthoredNeoScriptSource(record3)) return false;
+  if (containsCompiledNeoScriptBody(record3)) return false;
+  if (impactedSourceNames === null) return true;
+  const sourceIdentifiers = collectAuthoredNeoScriptSourceIdentifiers(record3);
+  if (sourceIdentifiers === null) return true;
+  return intersects(sourceIdentifiers, impactedSourceNames);
+}
+function collectImpactedSourceNames(args) {
+  const names = new Set(args.impactedTypeNames);
+  let recoveredContract = args.impactedTypeNames.size > 0;
+  const collectDocument = (document) => {
+    const classById = new Map(
+      document.classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
+    );
+    const ownerByConstructorId = constructorOwners(document);
+    const impactedValueIds = new Set(
+      (document.values ?? []).filter((value) => args.impactedIds.has(value.id)).map((value) => value.id)
+    );
+    const ownerByValueId = resolveOwnerMembersForValues(
+      document,
+      impactedValueIds
+    );
+    for (const owner of ownerByValueId.values()) {
+      recoveredContract = true;
+      collectDeclaredSourceNames(owner, names);
+      const ownerId = Reflect.get(owner, "id");
+      if (typeof ownerId !== "string") continue;
+      for (const classId of classPlacementsForMember(ownerId, document)) {
+        const schemaClass2 = classById.get(classId);
+        if (schemaClass2 !== void 0) {
+          collectDeclaredSourceNames(schemaClass2, names);
+        }
+      }
+    }
+    const records2 = [
+      ...document.classes,
+      ...document.members,
+      ...document.constructors ?? [],
+      ...document.enums,
+      ...document.interfaces ?? [],
+      ...document.values ?? []
+    ];
+    for (const record3 of records2) {
+      if (!args.impactedIds.has(record3.id)) continue;
+      recoveredContract = true;
+      collectDeclaredSourceNames(record3, names);
+      const ownerClassId = ownerByConstructorId.get(record3.id);
+      if (ownerClassId === void 0) continue;
+      const owner = classById.get(ownerClassId);
+      if (owner !== void 0) collectDeclaredSourceNames(owner, names);
+    }
+    for (const schemaClass2 of document.classes) {
+      if (!args.constructedClassIds.has(schemaClass2.id)) continue;
+      recoveredContract = true;
+      collectDeclaredSourceNames(schemaClass2, names);
+    }
+  };
+  collectDocument(args.currentDocument);
+  collectDocument(args.postDocument);
+  return recoveredContract ? names : null;
+}
+function collectDeclaredSourceNames(value, names) {
+  if (Array.isArray(value)) {
+    for (const child of value) collectDeclaredSourceNames(child, names);
+    return;
+  }
+  if (!isObjectRecord3(value)) return;
+  for (const [field, child] of Object.entries(value)) {
+    if (typeof child === "string" && (field === "name" || field === "sourceName" || field === "sourceFunctionName" || field === "declaredTypeName" || field === "typeName")) {
+      names.add(child);
+      continue;
+    }
+    collectDeclaredSourceNames(child, names);
+  }
+}
+function collectAuthoredNeoScriptSourceIdentifiers(value) {
+  const identifiers = /* @__PURE__ */ new Set();
+  let complete2 = true;
+  const collect = (child) => {
+    if (Array.isArray(child)) {
+      for (const entry of child) collect(entry);
+      return;
+    }
+    if (!isObjectRecord3(child)) return;
+    for (const [field, nested] of Object.entries(child)) {
+      if ((field === "code" || field === "setterCode") && typeof nested === "string") {
+        const result = lex(nested);
+        if (result.diagnostics.some(
+          (diagnostic) => diagnostic.severity === "error"
+        )) {
+          complete2 = false;
+        }
+        for (const token of result.tokens) {
+          if (token.kind === "identifier") identifiers.add(token.text);
+        }
+        continue;
+      }
+      collect(nested);
+    }
+  };
+  collect(value);
+  return complete2 ? identifiers : null;
 }
 function containsAuthoredNeoScriptSource(value) {
   if (Array.isArray(value)) {
@@ -68868,6 +69422,7 @@ var init_neo_script_recompile_scope = __esm({
   "../src/database/neo-script-recompile-scope.ts"() {
     "use strict";
     init_canonical_json();
+    init_src();
     init_member_kind_enum();
     init_inheritance();
     init_effective_storage();
@@ -69230,9 +69785,17 @@ function materializeInitializersLocallyV4(args) {
   );
   if (sourceRoots.size === 0) return { roots: [] };
   let document = readPulledProjectDocumentV4(records2);
-  const rootOwners = resolveOwnerMembersForValues(document, sourceRoots);
+  const rootKinds = /* @__PURE__ */ new Map();
+  const rootOwners = resolveOwnerMembersForValues(
+    document,
+    sourceRoots,
+    void 0,
+    void 0,
+    rootKinds
+  );
   const roots = [];
   for (const sourceValueId of sourceRoots) {
+    if (rootKinds.get(sourceValueId) === "declaration") continue;
     const rootOwner = rootOwners.get(sourceValueId);
     if (rootOwner === void 0) {
       throw new Error(
@@ -70280,18 +70843,26 @@ function replayAnimationDeclarationInitializersV4(records2, document) {
     const rootOwner = rootOwners.get(row.id);
     const rootOwnerId = Reflect.get(rootOwner ?? {}, "id");
     const initializerOwnerClass = typeof rootOwnerId !== "string" ? null : findSchemaPlacement(rootOwnerId, document.classes)?.ownerClass ?? null;
-    const replay = replayStoredConstructionV4({
-      records: pulled,
-      valueId: row.id,
-      code,
-      member: owner,
-      compileDocumentBodies: true,
-      initializerOwnerClass,
-      // A parameterized declaration is a template. Its arguments exist only
-      // at concrete construction sites, so validate the authored body here
-      // without fabricating values for the class header parameters.
-      evaluate: initializerOwnerClass?.requiredConstructorId === void 0 || initializerOwnerClass.requiredConstructorId === null
-    });
+    let replay;
+    try {
+      replay = replayStoredConstructionV4({
+        records: pulled,
+        valueId: row.id,
+        code,
+        member: owner,
+        compileDocumentBodies: true,
+        initializerOwnerClass,
+        // A parameterized declaration is a template. Its arguments exist only
+        // at concrete construction sites, so validate the authored body here
+        // without fabricating values for the class header parameters.
+        evaluate: initializerOwnerClass?.requiredConstructorId === void 0 || initializerOwnerClass.requiredConstructorId === null
+      });
+    } catch (error) {
+      throw new Error(
+        `Animation declaration replay failed for value "${row.id}": ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error }
+      );
+    }
     for (const [id2, value] of replay) {
       if (!isMemberValue(value)) {
         throw new Error(
@@ -73970,7 +74541,8 @@ function prepareServerOwnedSchemaCommit(args) {
   const hasValueChange = authoredChanges.some(
     (change) => change.recordKind === "value"
   );
-  if (!hasSchemaChange && !hasMigrationChange && !hasDialogueSourceChange && !hasValueChange) {
+  const hasAdditionalContractImpact = (args.additionalImpactedIds?.size ?? 0) > 0;
+  if (!hasSchemaChange && !hasMigrationChange && !hasDialogueSourceChange && !hasValueChange && !hasAdditionalContractImpact) {
     return authoredChanges;
   }
   const authoredPostDocument = applyProjectVersionWriteChanges(
@@ -73981,6 +74553,7 @@ function prepareServerOwnedSchemaCommit(args) {
     currentDocument: args.document,
     postDocument: authoredPostDocument,
     changes: authoredChanges,
+    additionalImpactedIds: args.additionalImpactedIds,
     forceRecompile: args.forceRecompile
   });
   const explicitlyChangedMemberIds = new Set(
@@ -77374,6 +77947,19 @@ function isOpaqueNSTypeInfo(value, ancestors = /* @__PURE__ */ new Set()) {
   if (value.type === 22) {
     return typeof value.interfaceId === "string" && value.interfaceId.length > 0;
   }
+  if (value.type === 25) {
+    if (!Array.isArray(value.argumentTypes) || ancestors.has(value)) {
+      return false;
+    }
+    ancestors.add(value);
+    try {
+      return isOpaqueNSFunctionReturnTypeInfo(value.returnTypeInfo) && value.argumentTypes.every(
+        (argument2) => isOpaqueNSTypeInfo(argument2, ancestors)
+      );
+    } finally {
+      ancestors.delete(value);
+    }
+  }
   if (value.type === 5 || value.type === 6) {
     if (ancestors.has(value)) return false;
     ancestors.add(value);
@@ -77403,6 +77989,11 @@ function opaqueTypeInfoContainsUnknown(value) {
   if (value.type === 5 || value.type === 6 || value.type === 9) {
     return isRecord8(value.entryTypeInfo) && opaqueTypeInfoContainsUnknown(value.entryTypeInfo);
   }
+  if (value.type === 25) {
+    return isRecord8(value.returnTypeInfo) && opaqueTypeInfoContainsUnknown(value.returnTypeInfo) || Array.isArray(value.argumentTypes) && value.argumentTypes.some(
+      (argument2) => isRecord8(argument2) && opaqueTypeInfoContainsUnknown(argument2)
+    );
+  }
   if (value.type !== 7 || !isRecord8(value.typeArguments)) return false;
   return Object.values(value.typeArguments).some(
     (argument2) => isRecord8(argument2) && opaqueTypeInfoContainsUnknown(argument2)
@@ -77417,6 +78008,10 @@ function isOpaqueNSFunctionReturnTypeInfo(value) {
 function isOpaqueNSFunctionArgumentTypeInfo(value) {
   return isOpaqueNSTypeInfo(value) && isOpaqueCallableIdentifier(value.name) && !opaqueTypeInfoContainsUnknown(value);
 }
+function isOpaqueConstructorArgumentTypeInfo(value) {
+  if (!isRecord8(value)) return false;
+  return isOpaqueNSTypeInfo(value) && (value.name === "value" || isOpaqueCallableIdentifier(value.name)) && !opaqueTypeInfoContainsUnknown(value);
+}
 function memberSignature(member) {
   if (member.kind === "property") {
     return `property:${member.settable === true}:${stableTypeInfo(member.typeInfo)}`;
@@ -78768,7 +79363,7 @@ function assertOpaqueConstructorValid(declaredConstructor) {
     );
   }
   const argumentTypes = declaredConstructor.argumentTypes;
-  if (!argumentTypes.every(isOpaqueNSFunctionArgumentTypeInfo)) {
+  if (!argumentTypes.every(isOpaqueConstructorArgumentTypeInfo)) {
     throw new Error(
       `Constructor "${declaredConstructor.id}" argumentTypes are invalid.`
     );
@@ -80546,6 +81141,7 @@ function replayStoredConstructionV4(args) {
     );
   }
   if (args.evaluate === false) return /* @__PURE__ */ new Map();
+  assertPulledConstructorsCompiled(document);
   const compiledDependencies = /* @__PURE__ */ new Set();
   let materialized;
   for (; ; ) {
@@ -80586,6 +81182,7 @@ function compilePulledProjectDocumentBodiesV4(document) {
   for (const constructor2 of compileArgs.constructors) {
     compileConstructorRecord({ ...compileArgs, constructor: constructor2 });
   }
+  assertPulledConstructorsCompiled(document);
   const ownerClassByMemberId = new Map(
     compileArgs.classes.flatMap(
       (schemaClass2) => Object.values(schemaClass2.schema).map(
@@ -80601,6 +81198,16 @@ function compilePulledProjectDocumentBodiesV4(document) {
     });
   }
 }
+function assertPulledConstructorsCompiled(document) {
+  const uncompiled = (document.constructors ?? []).find(
+    (constructor2) => !isNeoClassConstructor(constructor2)
+  );
+  if (uncompiled !== void 0) {
+    throw new Error(
+      `Constructor "${uncompiled.id}" was read from authored source but was not compiled before evaluation.`
+    );
+  }
+}
 function compilePulledMemberInitializerBodyV4(document, memberId) {
   const compileArgs = {
     project: document.project,
@@ -80628,7 +81235,8 @@ function compilePulledMemberInitializerBodyV4(document, memberId) {
 }
 function readPulledProjectDocumentV4(records2) {
   return readProjectDocument(
-    pulledProjectDocumentRaw(replayWorkspace(records2))
+    pulledProjectDocumentRaw(replayWorkspace(records2)),
+    { constructors: "authored-or-compiled" }
   );
 }
 function replayWorkspace(records2) {
@@ -80668,6 +81276,7 @@ var init_initializer_replay = __esm({
     init_project_document_read();
     init_server_preparation_preflight();
     init_projection();
+    init_constructors2();
     init_neoscript_evaluator();
   }
 });
@@ -81035,7 +81644,12 @@ function buildValueLowerContext(state, manifest, options = {}) {
   const classesByName = new Map(
     manifest.classes.map((entry) => [entry.name, entry])
   );
-  const declaredConstructorIndex = options.analysis === void 0 ? EMPTY_DECLARED_CONSTRUCTOR_INDEX : buildDeclaredConstructorIndex(options.analysis);
+  const sourceConstructorIndex = options.analysis === void 0 ? EMPTY_DECLARED_CONSTRUCTOR_INDEX : buildDeclaredConstructorIndex(options.analysis);
+  const declaredConstructorIndex = withPersistedConstructorSignatures(
+    sourceConstructorIndex,
+    manifest.classes,
+    manifest.constructors
+  );
   return {
     state,
     members,
@@ -87199,20 +87813,172 @@ async function fetchProjectDocument(workspace) {
       });
     }
   }
+  const revision = readProjectDocumentRevisionMarker2(raw);
   return {
     records: records2,
     heads,
-    raw
+    raw,
+    ...revision === null ? {} : { revision }
+  };
+}
+async function fetchProjectDocumentSyncMarker(workspace) {
+  const convex = await createConvexClient(workspace);
+  return queryProjectDocumentSyncMarker(workspace, convex);
+}
+async function queryProjectDocumentSyncMarker(workspace, convex) {
+  const [revisionValue, signal] = await Promise.all([
+    convex.query(api2.projectDocuments.getDocumentRevision, {
+      projectId: workspace.config.projectId,
+      versionId: workspace.config.versionId
+    }),
+    convex.query(api2.projectExportData.schemaSignal, {
+      projectId: workspace.config.projectId,
+      versionId: workspace.config.versionId
+    })
+  ]);
+  if (!isProjectDocumentRevisionMarker(revisionValue)) {
+    throw new Error(
+      "Project document revision query returned an invalid cursor marker."
+    );
+  }
+  return {
+    revision: revisionValue,
+    headTransactionId: signal?.transactionId ?? null,
+    headTransactionHash: signal?.transactionHash ?? null
+  };
+}
+async function fetchProjectDocumentDelta(workspace, cursor) {
+  const convex = await createConvexClient(workspace);
+  const marker = await queryProjectDocumentSyncMarker(workspace, convex);
+  if (marker.revision.versionsStamp !== cursor.versionsStamp) {
+    return {
+      fullResync: true,
+      headTransactionHash: marker.headTransactionHash
+    };
+  }
+  if (marker.headTransactionId === marker.revision.latestTransactionId && marker.headTransactionHash === workspace.state.headTransactionHash) {
+    return {
+      fullResync: false,
+      document: projectDocumentFromWorkspaceState(workspace.state, cursor),
+      changedKeys: /* @__PURE__ */ new Set(),
+      cursor,
+      headTransactionHash: marker.headTransactionHash
+    };
+  }
+  const result = await convex.query(api2.projectDocuments.getRecordsSince, {
+    projectId: workspace.config.projectId,
+    versionId: workspace.config.versionId,
+    sinceCreatedAt: cursor.createdAt,
+    seenTransactionIds: [...cursor.transactionIds]
+  });
+  if (result.fullResync) {
+    return {
+      fullResync: true,
+      headTransactionHash: marker.headTransactionHash
+    };
+  }
+  const document = projectDocumentFromWorkspaceState(workspace.state, cursor);
+  const { records: records2, heads } = document;
+  const changedKeys = /* @__PURE__ */ new Set();
+  for (const record3 of result.records) {
+    const key = `${record3.recordKind}:${record3.recordId}`;
+    changedKeys.add(key);
+    if (record3.deleted) {
+      records2.delete(key);
+      heads.set(key, {
+        recordKind: record3.recordKind,
+        recordId: record3.recordId,
+        contentHash: "",
+        deleted: true
+      });
+      continue;
+    }
+    if (record3.contentHash === null) {
+      throw new Error(
+        `Project document delta record "${key}" is live but has no content hash.`
+      );
+    }
+    records2.set(key, {
+      recordKind: record3.recordKind,
+      recordId: record3.recordId,
+      contentHash: record3.contentHash,
+      deleted: false,
+      data: record3.data
+    });
+    heads.set(key, {
+      recordKind: record3.recordKind,
+      recordId: record3.recordId,
+      contentHash: record3.contentHash,
+      deleted: false
+    });
+  }
+  const next = result.cursor ?? cursor;
+  const nextCursor = {
+    createdAt: next.createdAt,
+    transactionIds: [...next.transactionIds],
+    versionsStamp: marker.revision.versionsStamp
+  };
+  return {
+    fullResync: false,
+    document: projectDocumentWithRevision(document, nextCursor),
+    changedKeys,
+    cursor: nextCursor,
+    headTransactionHash: marker.headTransactionHash
   };
 }
-var fetchProjectDocumentRawChunked2, readProjectDocumentContentHashHeads2, SOURCE_RECORD_KINDS;
+function projectDocumentFromWorkspaceState(state, cursor) {
+  const records2 = serverRecordsFromWorkspaceState(state);
+  const heads = new Map(
+    [...records2].map(([key, record3]) => [
+      key,
+      {
+        recordKind: record3.recordKind,
+        recordId: record3.recordId,
+        contentHash: record3.contentHash,
+        deleted: false
+      }
+    ])
+  );
+  return projectDocumentWithRevision({ records: records2, heads, raw: {} }, cursor);
+}
+function projectDocumentWithRevision(document, cursor) {
+  return {
+    ...document,
+    revision: {
+      latestTransactionId: cursor.transactionIds[cursor.transactionIds.length - 1] ?? null,
+      latestTransactionCreatedAt: cursor.createdAt,
+      versionsStamp: cursor.versionsStamp
+    }
+  };
+}
+function serverRecordsFromWorkspaceState(state) {
+  const records2 = /* @__PURE__ */ new Map();
+  for (const [key, record3] of Object.entries(state.records)) {
+    if (record3.conflictServerHash === null) continue;
+    const conflictServerHash = record3.conflictServerHash;
+    const hasConflictServer = conflictServerHash !== void 0;
+    records2.set(key, {
+      recordKind: record3.recordKind,
+      recordId: record3.recordId,
+      contentHash: hasConflictServer ? conflictServerHash : record3.contentHash,
+      deleted: false,
+      data: hasConflictServer ? record3.conflictServerData : record3.data
+    });
+  }
+  return records2;
+}
+var fetchProjectDocumentRawChunked2, readProjectDocumentContentHashHeads2, readProjectDocumentRevisionMarker2, SOURCE_RECORD_KINDS;
 var init_document = __esm({
   "src/document.ts"() {
     "use strict";
     init_project_document_read();
     init_project2();
     init_convex();
-    ({ fetchProjectDocumentRawChunked: fetchProjectDocumentRawChunked2, readProjectDocumentContentHashHeads: readProjectDocumentContentHashHeads2 } = project_document_read_exports);
+    ({
+      fetchProjectDocumentRawChunked: fetchProjectDocumentRawChunked2,
+      readProjectDocumentContentHashHeads: readProjectDocumentContentHashHeads2,
+      readProjectDocumentRevisionMarker: readProjectDocumentRevisionMarker2
+    } = project_document_read_exports);
     SOURCE_RECORD_KINDS = new Set(
       Object.values(ProjectRecordKind)
     );
@@ -87899,6 +88665,7 @@ var init_static_value_seed_records = __esm({
 // src/commands/pull.ts
 var pull_exports = {};
 __export(pull_exports, {
+  deltaRequiresSourceProjectionV4: () => deltaRequiresSourceProjectionV4,
   projectSourcePathsRequiringRewriteV4: () => projectSourcePathsRequiringRewriteV4,
   runPull: () => runPull
 });
@@ -87915,6 +88682,15 @@ async function runPull(workspace, options) {
     await runResetPull(workspace);
     return;
   }
+  const progress = spinner("Checking local workspace\u2026");
+  try {
+    await runNormalPull(workspace, options, progress);
+  } catch (error) {
+    progress.fail("Pull failed.");
+    throw error;
+  }
+}
+async function runNormalPull(workspace, options, progress) {
   const destructive = options.force;
   const hasBaseline = Object.keys(workspace.state.records).length > 0;
   let localByKey = /* @__PURE__ */ new Map();
@@ -87943,25 +88719,54 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
       ])
     );
   }
-  if (!destructive && !options.regenerateSourceNames && workspace.state.headTransactionHash !== void 0) {
-    const convex = await createConvexClient(workspace);
-    const signal = await convex.query(api2.projectExportData.schemaSignal, {
-      projectId: workspace.config.projectId,
-      versionId: workspace.config.versionId
-    });
-    if (signal !== null && signal.transactionHash === workspace.state.headTransactionHash && localByKey.size > 0) {
-      const dirtyRecords = [...localByKey.entries()].some(([key, local]) => {
-        const base = workspace.state.records[key];
-        return base === void 0 || !authoredRecordsSemanticallyEqual(base.recordKind, local, base.data);
-      });
-      const dirtyBinaries = (localStatus?.binaryChanges?.length ?? 0) > 0;
-      if (!dirtyRecords && !dirtyBinaries) {
-        console.log("Already up to date (sync-signal head unchanged).");
+  let changedRecordKeys = null;
+  let nextCursor = null;
+  let observedHeadTransactionHash;
+  let document = null;
+  if (!destructive && hasBaseline) {
+    progress.update("Checking remote changes\u2026");
+    const cursor = workspace.state.documentRevisionCursor;
+    if (cursor !== void 0) {
+      const delta = await fetchProjectDocumentDelta(workspace, cursor);
+      observedHeadTransactionHash = delta.headTransactionHash;
+      if (!delta.fullResync) {
+        document = delta.document;
+        changedRecordKeys = delta.changedKeys;
+        nextCursor = delta.cursor;
+        if (delta.changedKeys.size === 0 && !options.regenerateSourceNames) {
+          const cursorChanged = !cursorsEqual(
+            workspace.state.documentRevisionCursor,
+            delta.cursor
+          );
+          const headChanged = workspace.state.headTransactionHash !== delta.headTransactionHash;
+          if (cursorChanged || headChanged) {
+            workspace.state.documentRevisionCursor = mutableCursor(
+              delta.cursor
+            );
+            workspace.state.headTransactionHash = delta.headTransactionHash;
+            writeWorkspaceState(workspace.root, workspace.state);
+          }
+          progress.succeed("Already up to date.");
+          return;
+        }
+      }
+    } else if (!options.regenerateSourceNames && workspace.state.headTransactionHash !== void 0) {
+      const marker = await fetchProjectDocumentSyncMarker(workspace);
+      observedHeadTransactionHash = marker.headTransactionHash;
+      if (marker.headTransactionId === marker.revision.latestTransactionId && marker.headTransactionHash === workspace.state.headTransactionHash) {
+        const seededCursor = cursorFromRevision(marker.revision);
+        workspace.state.documentRevisionCursor = mutableCursor(seededCursor);
+        writeWorkspaceState(workspace.root, workspace.state);
+        progress.succeed("Already up to date.");
         return;
       }
     }
   }
-  const document = await fetchProjectDocument(workspace);
+  if (document === null) {
+    progress.update("Downloading full project snapshot\u2026");
+    document = await fetchProjectDocument(workspace);
+    nextCursor = document.revision === void 0 ? null : cursorFromRevision(document.revision);
+  }
   const plans = /* @__PURE__ */ new Map();
   let mergedCount = 0;
   let conflictCount = 0;
@@ -88081,7 +88886,11 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
     conflictKeys,
     localStatus,
     destructive,
-    regenerateSourceNames: destructive || options.regenerateSourceNames
+    regenerateSourceNames: destructive || options.regenerateSourceNames,
+    changedRecordKeys,
+    nextCursor,
+    observedHeadTransactionHash,
+    progress
   });
 }
 async function runResetPull(workspace) {
@@ -88111,10 +88920,17 @@ async function runResetPull(workspace) {
         projectId: workspace.config.projectId,
         versionId: workspace.config.versionId
       });
-      workspace.state.headTransactionHash = signal?.transactionHash ?? null;
+      workspace.state.headTransactionHash = document.revision !== void 0 && signal?.transactionId === document.revision.latestTransactionId ? signal.transactionHash : null;
     } catch {
       workspace.state.headTransactionHash = null;
     }
+    if (document.revision !== void 0) {
+      workspace.state.documentRevisionCursor = mutableCursor(
+        cursorFromRevision(document.revision)
+      );
+    } else {
+      delete workspace.state.documentRevisionCursor;
+    }
     writeWorkspaceState(workspace.root, workspace.state);
     progress.succeed(
       `Pulled ${document.records.size} records \u2014 ${reset.written} file(s) updated \u2014 ${reset.removed} removed.`
@@ -88134,8 +88950,30 @@ async function finishFormat4Pull(args) {
     conflictKeys,
     localStatus,
     destructive,
-    regenerateSourceNames
+    regenerateSourceNames,
+    changedRecordKeys,
+    nextCursor,
+    observedHeadTransactionHash,
+    progress
   } = args;
+  if (changedRecordKeys !== null && !regenerateSourceNames && conflictCount === 0 && localStatus !== null && !deltaRequiresSourceProjectionV4({
+    workspace,
+    document,
+    plans,
+    localStatus,
+    changedRecordKeys
+  })) {
+    finishRecordOnlyDeltaPull({
+      workspace,
+      document,
+      changedRecordKeys,
+      nextCursor,
+      observedHeadTransactionHash,
+      progress
+    });
+    return;
+  }
+  progress.update("Regenerating affected Neo sources\u2026");
   const plannedLocalRecords = buildEmitRecordSet(document, plans, "emit");
   for (const [key, record3] of staticValueSeedEmitRecords(
     localStatus,
@@ -88150,7 +88988,7 @@ async function finishFormat4Pull(args) {
     )
   );
   const localResult = emitProjectDocumentFilesV4(localRecords);
-  const serverResult = emitProjectDocumentFilesV4(
+  const serverResult = conflictCount === 0 ? null : emitProjectDocumentFilesV4(
     buildEmitRecordSet(document, plans, "server")
   );
   const binaries = await pullProjectBinariesV4({
@@ -88164,11 +89002,11 @@ async function finishFormat4Pull(args) {
     localResult.files.map((file) => [file.path, file])
   );
   const serverByPath = new Map(
-    serverResult.files.map((file) => [file.path, file])
+    (serverResult?.files ?? []).map((file) => [file.path, file])
   );
   const conflictPaths = /* @__PURE__ */ new Set();
   for (const key of conflictKeys) {
-    const path = localResult.recordFiles.get(key) ?? serverResult.recordFiles.get(key);
+    const path = localResult.recordFiles.get(key) ?? serverResult?.recordFiles.get(key);
     if (path) conflictPaths.add(path);
   }
   const emittedPaths = /* @__PURE__ */ new Set([
@@ -88180,7 +89018,7 @@ async function finishFormat4Pull(args) {
     localStatus,
     plans,
     localRecordFiles: localResult.recordFiles,
-    serverRecordFiles: serverResult.recordFiles,
+    serverRecordFiles: serverResult?.recordFiles ?? /* @__PURE__ */ new Map(),
     previousRecords: workspace.state.records,
     conflictPaths,
     emittedPaths,
@@ -88230,7 +89068,7 @@ async function finishFormat4Pull(args) {
       if (baseState) records2[key] = { ...baseState };
       continue;
     }
-    const file = localResult.recordFiles.get(key) ?? serverResult.recordFiles.get(key);
+    const file = localResult.recordFiles.get(key) ?? serverResult?.recordFiles.get(key) ?? baseState?.file;
     records2[key] = plan.conflicted ? {
       recordKind,
       recordId,
@@ -88249,7 +89087,7 @@ async function finishFormat4Pull(args) {
   }
   for (const [key, serverRecord] of document.records) {
     if (serverRecord.deleted || records2[key]) continue;
-    const file = localResult.recordFiles.get(key) ?? serverResult.recordFiles.get(key);
+    const file = localResult.recordFiles.get(key) ?? serverResult?.recordFiles.get(key);
     records2[key] = {
       recordKind: serverRecord.recordKind,
       recordId: serverRecord.recordId,
@@ -88263,30 +89101,37 @@ async function finishFormat4Pull(args) {
     if (record3) record3.projectBinary = state;
   }
   workspace.state.records = records2;
-  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;
+  if (nextCursor !== null) {
+    workspace.state.documentRevisionCursor = mutableCursor(nextCursor);
+  }
+  if (observedHeadTransactionHash !== void 0) {
+    workspace.state.headTransactionHash = observedHeadTransactionHash;
+  } else {
+    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 = document.revision !== void 0 && signal?.transactionId === document.revision.latestTransactionId ? signal.transactionHash : null;
+    } catch {
+      workspace.state.headTransactionHash = null;
+    }
   }
   writeWorkspaceState(workspace.root, workspace.state);
   if (conflictCount === 0) {
     writeProjectSourceAnalysisCacheV4(workspace.root, localResult.analysis);
-    writeMaterializedConstructionBuildCacheV1(
-      workspace.root,
-      workspace.state,
-      // The cache is a baseline for workspace.state, not the merged authored
-      // tree. Retaining a local constructor edit here would bless it as the
-      // pulled construction and bypass the P61 recreate-conflict check.
-      serverResult.materializedConstructors
-    );
+    if (localStatus === null || localStatus.changes.length === 0) {
+      writeMaterializedConstructionBuildCacheV1(
+        workspace.root,
+        workspace.state,
+        localResult.materializedConstructors
+      );
+    }
   }
+  const pulledRecords = changedRecordKeys === null ? `Pulled ${document.records.size} records` : `Pulled ${changedRecordKeys.size} changed record(s)`;
   const summary = [
-    `Pulled ${document.records.size} records`,
+    pulledRecords,
     `${written} file(s) updated`,
     `${removed} removed`
   ];
@@ -88297,7 +89142,7 @@ async function finishFormat4Pull(args) {
   if (mergedCount > 0)
     summary.push(color.green(`${mergedCount} merged cleanly`));
   if (conflictCount > 0) summary.push(color.red(`${conflictCount} CONFLICTED`));
-  console.log(`${summary.join(" \u2014 ")}.`);
+  progress.succeed(`${summary.join(" \u2014 ")}.`);
   if (conflictCount > 0) {
     warn(
       'Conflict markers were written into the affected files. Edit them to the desired final state and push \u2014 the push is the resolution. To keep one side everywhere, use "neo resolve --mine" or "neo resolve --theirs".'
@@ -88311,6 +89156,98 @@ async function finishFormat4Pull(args) {
     for (const path of binaries.conflicts) console.log(`  ${sym.fail} ${path}`);
   }
 }
+function deltaRequiresSourceProjectionV4(args) {
+  const mainLocale = workspaceMainLocale(args.workspace.state.records);
+  for (const key of args.changedRecordKeys) {
+    const previous = args.workspace.state.records[key];
+    const local = args.localStatus.reconstructed.get(key)?.fullData;
+    const plan = args.plans.get(key);
+    const server = args.document.records.get(key);
+    if (server === void 0) {
+      if (previous?.file !== void 0 || local !== void 0) return true;
+      continue;
+    }
+    if (local === void 0 || plan?.emitData === void 0) {
+      if (previous?.file !== void 0 || previous === void 0) return true;
+      continue;
+    }
+    if (!sourceAuthoredRecordsSemanticallyEqual(
+      server.recordKind,
+      plan.emitData,
+      local,
+      mainLocale
+    )) {
+      return true;
+    }
+  }
+  return false;
+}
+function finishRecordOnlyDeltaPull(args) {
+  const cachedExpressions = readMaterializedConstructionBuildCacheV1(
+    args.workspace.root,
+    args.workspace.state
+  );
+  const records2 = { ...args.workspace.state.records };
+  for (const key of args.changedRecordKeys) {
+    const server = args.document.records.get(key);
+    if (server === void 0) {
+      delete records2[key];
+      continue;
+    }
+    const previous = records2[key];
+    records2[key] = {
+      recordKind: server.recordKind,
+      recordId: server.recordId,
+      contentHash: server.contentHash,
+      data: server.data,
+      ...previous?.file === void 0 ? {} : { file: previous.file },
+      ...previous?.projectBinary === void 0 ? {} : { projectBinary: previous.projectBinary }
+    };
+  }
+  args.workspace.state.records = records2;
+  if (args.nextCursor !== null) {
+    args.workspace.state.documentRevisionCursor = mutableCursor(
+      args.nextCursor
+    );
+  }
+  if (args.observedHeadTransactionHash !== void 0) {
+    args.workspace.state.headTransactionHash = args.observedHeadTransactionHash;
+  }
+  writeWorkspaceState(args.workspace.root, args.workspace.state);
+  if (cachedExpressions !== null) {
+    writeMaterializedConstructionBuildCacheV1(
+      args.workspace.root,
+      args.workspace.state,
+      cachedExpressions
+    );
+  }
+  args.progress.succeed(
+    `Pulled ${args.changedRecordKeys.size} changed record(s) \u2014 0 file(s) updated \u2014 0 removed.`
+  );
+}
+function cursorFromRevision(revision) {
+  return {
+    createdAt: revision.latestTransactionCreatedAt,
+    transactionIds: revision.latestTransactionId === null ? [] : [revision.latestTransactionId],
+    versionsStamp: revision.versionsStamp
+  };
+}
+function mutableCursor(cursor) {
+  return {
+    createdAt: cursor.createdAt,
+    transactionIds: [...cursor.transactionIds],
+    versionsStamp: cursor.versionsStamp
+  };
+}
+function cursorsEqual(left, right) {
+  if (left === void 0) return false;
+  if (left.createdAt !== right.createdAt) return false;
+  if (left.versionsStamp !== right.versionsStamp) return false;
+  if (left.transactionIds.length !== right.transactionIds.length) return false;
+  return left.transactionIds.every(
+    (transactionId, index) => transactionId === right.transactionIds[index]
+  );
+}
 function projectSourcePathsRequiringRewriteV4(args) {
   if (args.destructive || args.localStatus === null) {
     return new Set(args.emittedPaths);