@neocompose/cli 0.1.2 → 0.1.4

package/dist/neo.mjs

@@ -1149,7 +1149,7 @@ var init_projection = __esm({
       Custom: 7,
       Enum: 8,
       Lookup: 9,
-      NSGetter: 10,
+      NSProperty: 10,
       Sprite: 11,
       Audio: 12,
       Function: 13,
@@ -1174,7 +1174,7 @@ var init_projection = __esm({
       [ATTRIBUTE_TYPE.Enum]: "NeoEnum",
       [ATTRIBUTE_TYPE.Lookup]: "NeoLookup",
       [ATTRIBUTE_TYPE.DialogueLookup]: "NeoDialogueLookup",
-      [ATTRIBUTE_TYPE.NSGetter]: "NeoGetter",
+      [ATTRIBUTE_TYPE.NSProperty]: "NeoProperty",
       [ATTRIBUTE_TYPE.Sprite]: "NeoSprite",
       [ATTRIBUTE_TYPE.Audio]: "NeoAudio",
       [ATTRIBUTE_TYPE.Function]: "NeoFunction",
@@ -1197,7 +1197,8 @@ var init_projection = __esm({
       "createdAt",
       "updatedAt",
       "valueId",
-      "getter"
+      "getter",
+      "setter"
     ];
     TYPE_VOLATILE_FIELDS = [
       "projectId",
@@ -2180,17 +2181,19 @@ function reconstructProperty(file, property, context) {
       data.multiselect = shape.head === "IReadOnlyList";
       break;
     }
-    case ATTRIBUTE_TYPE.NSGetter: {
+    case ATTRIBUTE_TYPE.NSProperty: {
       const code = namedString(marker, "Code", file);
-      if (code === void 0) {
+      if (code === void 0 && typeof data.extendsAttributeId !== "string") {
         throw new SchemaParseError(
-          "[NeoGetter] requires a Code argument.",
+          "[NeoProperty] requires a Code argument.",
           file,
           marker.line,
           marker.column
         );
       }
-      data.code = code;
+      if (code !== void 0) data.code = code;
+      const setterCode = namedString(marker, "SetterCode", file);
+      if (setterCode !== void 0) data.setterCode = setterCode;
       const retJson = parseJsonArg(marker, "RetJson", file);
       if (retJson !== void 0) data.returnTypeInfo = retJson;
       break;
@@ -3631,11 +3634,12 @@ namespace NeoCompose.Schema
     }
 
     [AttributeUsage(AttributeTargets.Property)]
-    public sealed class NeoGetterAttribute : NeoSchemaMemberAttribute
+    public sealed class NeoPropertyAttribute : NeoSchemaMemberAttribute
     {
         public string? Code { get; set; }
+        public string? SetterCode { get; set; }
         public string? RetJson { get; set; }
-        public NeoGetterAttribute(string? id = null) : base(id) { }
+        public NeoPropertyAttribute(string? id = null) : base(id) { }
     }
 
     [AttributeUsage(AttributeTargets.Property)]
@@ -3963,12 +3967,24 @@ function isGenericBindingsRecord(value) {
   if (Array.isArray(value)) return false;
   return Object.values(value).every(isGenericBinding);
 }
+function dedupeSchemaKeyOrder(order) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const schemaKey of order) {
+    if (seen.has(schemaKey)) continue;
+    seen.add(schemaKey);
+    result.push(schemaKey);
+  }
+  return result;
+}
 function getCustomTypeSchemaKeyOrder(type) {
   const schemaKeys = Object.keys(type.schema);
   if (type.schemaKeyOrder === void 0) return schemaKeys;
-  const orderedKeys = [...type.schemaKeyOrder];
+  const orderedKeys = dedupeSchemaKeyOrder(type.schemaKeyOrder);
+  const seen = new Set(orderedKeys);
   for (const schemaKey of schemaKeys) {
-    if (orderedKeys.includes(schemaKey)) continue;
+    if (seen.has(schemaKey)) continue;
+    seen.add(schemaKey);
     orderedKeys.push(schemaKey);
   }
   return orderedKeys;
@@ -4171,11 +4187,15 @@ function isAttributeDialogueLookupBase(value) {
   if (typeof v.multiselect !== "boolean") return false;
   return v.dialogueGroupId === null || typeof v.dialogueGroupId === "string";
 }
-function isAttributeNSGetterBase(value) {
-  const v = asTypedAttributeBase(value, 10 /* NSGetter */);
+function isAttributeNSPropertyBase(value) {
+  const v = asTypedAttributeBase(value, 10 /* NSProperty */);
   if (v === null) return false;
   if (typeof v.code !== "string") return false;
   if (v.code.length === 0) return false;
+  if (v.setterCode !== void 0 && typeof v.setterCode !== "string") {
+    return false;
+  }
+  if (v.setterCode !== void 0 && v.setterCode.length === 0) return false;
   return isNSTypeInfo(v.returnTypeInfo);
 }
 function isAttributeFunctionBase(value) {
@@ -4226,7 +4246,7 @@ var init_attribute_types = __esm({
       AttributeType10[AttributeType10["Custom"] = 7] = "Custom";
       AttributeType10[AttributeType10["Enum"] = 8] = "Enum";
       AttributeType10[AttributeType10["Lookup"] = 9] = "Lookup";
-      AttributeType10[AttributeType10["NSGetter"] = 10] = "NSGetter";
+      AttributeType10[AttributeType10["NSProperty"] = 10] = "NSProperty";
       AttributeType10[AttributeType10["Sprite"] = 11] = "Sprite";
       AttributeType10[AttributeType10["Audio"] = 12] = "Audio";
       AttributeType10[AttributeType10["Function"] = 13] = "Function";
@@ -4487,7 +4507,7 @@ var init_generics = __esm({
       0 /* Null */,
       9 /* Lookup */,
       18 /* DialogueLookup */,
-      10 /* NSGetter */,
+      10 /* NSProperty */,
       13 /* Function */,
       21 /* Generic */
     ]);
@@ -6530,14 +6550,21 @@ function emitProperty(context, schemaKey, attributeRecord, memberNames, warnings
       csType = multiselect ? "IReadOnlyList<NeoDialogueLookupRef>" : "NeoDialogueLookupRef";
       break;
     }
-    case ATTRIBUTE_TYPE.NSGetter: {
-      if (typeof data.code !== "string") {
+    case ATTRIBUTE_TYPE.NSProperty: {
+      const isOverride = typeof data.extendsAttributeId === "string";
+      if (!isOverride && typeof data.code !== "string") {
         throw new Error(
-          `Getter attribute "${attributeRecord.recordId}" is missing "code".`
+          `NeoScript property "${attributeRecord.recordId}" is missing "code".`
         );
       }
-      delete remaining.code;
-      args.push(`Code = ${csVerbatimString(data.code)}`);
+      if (typeof data.code === "string") {
+        delete remaining.code;
+        args.push(`Code = ${csVerbatimString(data.code)}`);
+      }
+      if (typeof data.setterCode === "string") {
+        delete remaining.setterCode;
+        args.push(`SetterCode = ${csVerbatimString(data.setterCode)}`);
+      }
       if (data.returnTypeInfo !== void 0) {
         delete remaining.returnTypeInfo;
         args.push(
@@ -6885,9 +6912,10 @@ import {
 } from "node:fs";
 import { dirname as dirname2, join as join6 } from "node:path";
 async function runPull(workspace, options) {
+  const destructive = options.force || options.reset;
   const hasBaseline = Object.keys(workspace.state.records).length > 0;
   let localByKey = /* @__PURE__ */ new Map();
-  if (hasBaseline && !options.force) {
+  if (hasBaseline && !destructive) {
     const status = computeWorkspaceStatus(workspace);
     if (status.conflictedFiles.length > 0) {
       throw new Error(
@@ -6907,7 +6935,7 @@ ${status.parseErrors.map((error) => `  ${error.message}`).join("\n")}`
       ])
     );
   }
-  if (!options.force && workspace.state.headTransactionHash !== void 0) {
+  if (!destructive && workspace.state.headTransactionHash !== void 0) {
     const convex = await createConvexClient(workspace);
     const signal = await convex.query(api2.projectExportData.schemaSignal, {
       projectId: workspace.config.projectId,
@@ -6933,7 +6961,7 @@ ${status.parseErrors.map((error) => `  ${error.message}`).join("\n")}`
     if (serverRecord.deleted) continue;
     const baseState = workspace.state.records[key];
     const local = localByKey.get(key);
-    if (options.force || baseState === void 0) {
+    if (destructive || baseState === void 0) {
       plans.set(key, {
         emitData: serverRecord.data,
         serverHash: serverRecord.contentHash,
@@ -7338,7 +7366,7 @@ async function runInit(options) {
     config,
     state: readWorkspaceState(root)
   };
-  await runPull(workspace, { force: false });
+  await runPull(workspace, { force: false, reset: false });
 }
 var init_init = __esm({
   "src/commands/init.ts"() {
@@ -7508,11 +7536,17 @@ var init_compile_error = __esm({
     CompileError = class extends Error {
       line;
       column;
-      constructor(message, pos) {
+      unit;
+      constructor(message, pos, unit) {
         super(`${pos.line}:${pos.column}: ${message}`);
         this.name = "CompileError";
         this.line = pos.line;
         this.column = pos.column;
+        this.unit = unit;
+      }
+      withUnit(unit) {
+        if (this.unit === void 0) this.unit = unit;
+        return this;
       }
     };
   }
@@ -9545,6 +9579,7 @@ var init_resolver = __esm({
     init_project();
     init_neoscript();
     init_compile_error();
+    init_core();
     Scope = class {
       constructor(parent) {
         this.parent = parent;
@@ -9628,11 +9663,27 @@ var init_resolver = __esm({
             }
           }
         } : null;
+        if (ctx.mode === "setter" /* Setter */) {
+          if (ctx.valueTypeInfo === void 0) {
+            throw new Error("Resolver: Setter mode requires valueTypeInfo");
+          }
+          this.valueVariable = {
+            id: "__value__",
+            typeInfo: ctx.valueTypeInfo,
+            pointer: {
+              type: "value" /* value */,
+              value: { typeInfo: ctx.valueTypeInfo, value: null }
+            }
+          };
+        } else {
+          this.valueVariable = null;
+        }
       }
       ctx;
       thisVariable;
       rootVariable;
       contextVariable;
+      valueVariable;
       /**
        * Synthesized `Root` type. The resolver fabricates this from the project's
        * root attribute ids so the body's `root.Assets` / `root.Save` /
@@ -9669,6 +9720,13 @@ var init_resolver = __esm({
             variableId: this.contextVariable.id
           });
         }
+        if (this.valueVariable) {
+          scope.define({
+            name: "value",
+            type: this.valueVariable.typeInfo,
+            variableId: this.valueVariable.id
+          });
+        }
         if (this.ctx.migrationContext === true) {
           scope.define({
             name: "source",
@@ -9686,6 +9744,7 @@ var init_resolver = __esm({
           const instructions = this.resolveStatements(body.body, scope);
           const parameters = [this.thisVariable, this.rootVariable];
           if (this.contextVariable) parameters.push(this.contextVariable);
+          if (this.valueVariable) parameters.push(this.valueVariable);
           return {
             parameters,
             instructions,
@@ -9728,6 +9787,12 @@ var init_resolver = __esm({
       resolveStatement(stmt, scope) {
         switch (stmt.kind) {
           case "varDecl": {
+            if (this.valueVariable && stmt.name === "value") {
+              throw new CompileError(
+                "Cannot declare a local named 'value' because it is the setter value parameter.",
+                stmt.pos
+              );
+            }
             const declared = this.resolveTypeAnnotation(stmt.type);
             const initResolved = this.resolveExpr(stmt.init, scope, declared);
             if (!isAssignable(initResolved.type, declared, this.ctx.types)) {
@@ -9804,7 +9869,7 @@ var init_resolver = __esm({
           }
           case "return": {
             const expectedReturn = this.currentExpectedReturn();
-            const inActionBody = this.ctx.mode === "action" /* Action */ && this.lambdaDepth === 0;
+            const inActionBody = this.ctx.mode !== "getter" /* Getter */ && this.lambdaDepth === 0;
             if (stmt.expr === null) {
               if (inActionBody) {
                 return {
@@ -9827,7 +9892,7 @@ var init_resolver = __esm({
             if (inActionBody) {
               if (resolved.type.type !== 0 /* Null */) {
                 throw new CompileError(
-                  `Action functions can only return null; got ${describeType(resolved.type)}`,
+                  `${this.ctx.mode === "setter" /* Setter */ ? "Setter" : "Action"} functions can only return null; got ${describeType(resolved.type)}`,
                   stmt.pos
                 );
               }
@@ -9873,15 +9938,17 @@ var init_resolver = __esm({
             );
             if (!localAssignmentEntry && !this.ctx.allowMutation) {
               throw new CompileError(
-                "Only local variable assignment is allowed in getter contexts; save mutations require an action.",
+                "Only local variable assignment is allowed in getter contexts; save mutations require an action or setter.",
                 stmt.pos
               );
             }
-            const writability = localAssignmentEntry ? "local" /* Local */ : this.validateWritableTarget(stmt.target, scope, stmt.pos);
-            if (!localAssignmentEntry) {
-              this.validateNonGetterAssignmentTarget(stmt.target, scope, stmt.pos);
-            }
-            const readTarget = this.resolveExpr(stmt.target, scope);
+            const propertyTarget = localAssignmentEntry ? null : this.resolveNSPropertyAssignmentTarget(
+              stmt.target,
+              scope,
+              stmt.pos
+            );
+            const writability = localAssignmentEntry ? "local" /* Local */ : propertyTarget !== null ? "setter" /* Setter */ : this.validateWritableTarget(stmt.target, scope, stmt.pos);
+            const readTarget = propertyTarget ?? this.resolveExpr(stmt.target, scope);
             const target = localAssignmentEntry ? { pointer: readTarget.pointer, type: localAssignmentEntry.type } : readTarget;
             let value;
             if (stmt.op === "=") {
@@ -10668,7 +10735,7 @@ var init_resolver = __esm({
         if (attr === null) return "inherit" /* Inherit */;
         return this.getStorageResolver().declaredStorage(attr.id);
       }
-      validateNonGetterAssignmentTarget(expr, scope, pos) {
+      validateNSPropertyCollectionMutationTarget(expr, scope, pos) {
         if (expr.kind !== "member") return;
         const attr = this.resolveMemberAttribute(
           expr.receiver,
@@ -10676,11 +10743,42 @@ var init_resolver = __esm({
           scope,
           pos
         );
-        if (attr?.type !== 10 /* NSGetter */) return;
+        if (attr?.type !== 10 /* NSProperty */) return;
         throw new CompileError(
-          `Cannot assign to getter attribute '${attr.name}' because getter attributes are read-only.`,
+          `Cannot call mutating methods on NeoScript property '${attr.name}'; assign a whole value via its setter instead.`,
+          pos
+        );
+      }
+      /** Resolve a whole-value assignment to a setter-backed NSProperty. */
+      resolveNSPropertyAssignmentTarget(expr, scope, pos) {
+        if (expr.kind !== "member") return null;
+        const attr = this.resolveMemberAttribute(
+          expr.receiver,
+          expr.name,
+          scope,
           pos
         );
+        if (attr?.type !== 10 /* NSProperty */) return null;
+        if (expr.optional === true) {
+          throw new CompileError(
+            `Cannot assign to NeoScript property '${attr.name}' through an optional receiver.`,
+            pos
+          );
+        }
+        const receiver = this.resolveExpr(expr.receiver, scope);
+        if (!receiver.type.required) {
+          throw new CompileError(
+            `Cannot assign to NeoScript property '${attr.name}' through an optional receiver.`,
+            pos
+          );
+        }
+        if (!this.resolveNSPropertySetterSource(attr.id)) {
+          throw new CompileError(
+            `Cannot assign to NeoScript property '${attr.name}' because it does not declare a setter.`,
+            pos
+          );
+        }
+        return this.resolveExpr(expr, scope);
       }
       resolveMemberAttribute(receiverAst, name, scope, pos) {
         const receiver = this.resolveExpr(receiverAst, scope);
@@ -11060,8 +11158,8 @@ var init_resolver = __esm({
               pos
             );
           }
-          if (attr.type === 10 /* NSGetter */) {
-            const returnType = this.resolveNSGetterReturnType(attr.id);
+          if (attr.type === 10 /* NSProperty */) {
+            const returnType = this.resolveNSPropertyReturnType(attr.id);
             if (!returnType) {
               throw new CompileError(
                 `Getter '${attr.name}' has no \`returnTypeInfo\` (broken override chain?)`,
@@ -11646,10 +11744,14 @@ var init_resolver = __esm({
             pos
           );
         }
-        const writability = localMutation ? "local" /* Local */ : this.validateWritableTarget(callee.receiver, scope, pos);
         if (!localMutation) {
-          this.validateNonGetterAssignmentTarget(callee.receiver, scope, pos);
+          this.validateNSPropertyCollectionMutationTarget(
+            callee.receiver,
+            scope,
+            pos
+          );
         }
+        const writability = localMutation ? "local" /* Local */ : this.validateWritableTarget(callee.receiver, scope, pos);
         const args = this.resolveCollectionMutationArgs(
           callee,
           expr.args,
@@ -11893,9 +11995,9 @@ var init_resolver = __esm({
             pos
           );
         }
-        if (signature.deferred && this.ctx.mode !== "action" /* Action */) {
+        if (signature.deferred && this.ctx.mode === "getter" /* Getter */) {
           throw new CompileError(
-            `Deferred Function '${attr.name}' can only be called from dialogue action code.`,
+            `Deferred Function '${attr.name}' can only be called from action or setter code.`,
             pos
           );
         }
@@ -12076,7 +12178,7 @@ var init_resolver = __esm({
       }
       /**
        * Maps an attribute to the TNSTypeInfo the compiler exposes to user code.
-       * NSGetter attributes expose their `returnTypeInfo`. Lookup attributes
+       * NSProperty attributes expose their `returnTypeInfo`. Lookup attributes
        * resolve to the *referenced collection's entry type* so `lookup.field`
        * autocompletes naturally.
        *
@@ -12232,10 +12334,10 @@ var init_resolver = __esm({
             }
             return { type: 18 /* DialogueLookup */, required };
           }
-          case 10 /* NSGetter */:
-            if (!isAttributeNSGetterBase(attr)) {
+          case 10 /* NSProperty */:
+            if (!isAttributeNSPropertyBase(attr)) {
               throw new CompileError(
-                `NSGetter attribute ${attr.id} failed isAttributeNSGetterBase`,
+                `NSProperty attribute ${attr.id} failed isAttributeNSPropertyBase`,
                 { line: 1, column: 1 }
               );
             }
@@ -12418,26 +12520,38 @@ var init_resolver = __esm({
         return t;
       }
       /**
-       * Walks an NSGetter attribute's `extendsAttributeId` chain to find
+       * Walks an NSProperty attribute's `extendsAttributeId` chain to find
        * the first non-`undefined` `returnTypeInfo`.
        *
        * Override rows don't carry their own `returnTypeInfo` (per spec
        * § 1.2) — they inherit from their parent. The walk terminates at
        * the first row with `returnTypeInfo` set, the chain end (no
-       * `extendsAttributeId`), or a non-NSGetter row (broken chain).
+       * `extendsAttributeId`), or a non-NSProperty row (broken chain).
        */
-      resolveNSGetterReturnType(attrId) {
+      resolveNSPropertyReturnType(attrId) {
         const found = walkExtendsAttributeChain(
           attrId,
           this.ctx.attributes,
-          // `requireType: AttributeType.NSGetter` only feeds NSGetter rows
+          // `requireType: AttributeType.NSProperty` only feeds NSProperty rows
           // into this picker, but TS doesn't carry the filter through.
-          // `isAttributeNSGetterBase` narrows on the field set and returns
+          // `isAttributeNSPropertyBase` narrows on the field set and returns
           // a typed `returnTypeInfo` directly. Override rows that lack
           // their own `returnTypeInfo` fail the guard, which is the
           // correct "keep walking the chain" signal.
-          (a) => isAttributeNSGetterBase(a) ? a.returnTypeInfo : void 0,
-          { requireType: 10 /* NSGetter */ }
+          (a) => isAttributeNSPropertyBase(a) ? a.returnTypeInfo : void 0,
+          { requireType: 10 /* NSProperty */ }
+        );
+        return found ?? null;
+      }
+      resolveNSPropertySetterSource(attrId) {
+        const found = walkExtendsAttributeChain(
+          attrId,
+          this.ctx.attributes,
+          (attribute) => {
+            const setterCode = getField(attribute, "setterCode");
+            return typeof setterCode === "string" ? setterCode : void 0;
+          },
+          { requireType: 10 /* NSProperty */ }
         );
         return found ?? null;
       }
@@ -12485,6 +12599,17 @@ function compileNSAction(code, ctx) {
   });
   return resolver.compileAction(ast);
 }
+function compileNSSetter(code, ctx) {
+  const ast = parseFunctionBody(code);
+  const resolver = new Resolver({
+    ...ctx,
+    returnTypeInfo: { type: 0 /* Null */, required: true },
+    mode: "setter" /* Setter */,
+    allowMutation: true,
+    dialogueContext: null
+  });
+  return resolver.compileAction(ast);
+}
 var init_compile = __esm({
   "../src/database/neoscript/compile.ts"() {
     "use strict";
@@ -12807,6 +12932,19 @@ function evaluateNSAction(action, ctx) {
   }
   return { writes };
 }
+function evaluateNSSetter(setter, ctx, value, writes) {
+  const scope = createTopLevelScope(ctx);
+  scope.set("__value__", value);
+  const result = evalInstructions(setter.instructions, scope, ctx, {
+    allowFallthroughReturn: true,
+    writes
+  });
+  if (result.kind === "return" && result.value !== null && result.value !== void 0) {
+    throw new NSGetterRuntimeError(
+      `Setter returned a non-null value: ${String(result.value)}`
+    );
+  }
+}
 function createTopLevelScope(ctx) {
   const scope = /* @__PURE__ */ new Map();
   scope.set("__this__", ctx.thisValue);
@@ -12869,6 +13007,21 @@ function evalInstructions(instructions, scope, ctx, options) {
           scope.set(ins.target.pointer.variableId, value);
           break;
         }
+        if (ins.target.writability === "setter" /* Setter */) {
+          if (!options.writes) {
+            throw new NSGetterRuntimeError(
+              "Setter calls cannot be evaluated in getter context."
+            );
+          }
+          dispatchNSSetter(
+            ins.target.pointer,
+            value,
+            scope,
+            ctx,
+            options.writes
+          );
+          break;
+        }
         validateAssignmentTarget(ins.target.pointer, scope, ctx);
         if (!options.writes) {
           throw new NSGetterRuntimeError(
@@ -12878,7 +13031,8 @@ function evalInstructions(instructions, scope, ctx, options) {
         options.writes.push({
           kind: "assign",
           target: ins.target,
-          value
+          value,
+          ...resolvedDestinationFieldsForAssign(ins.target.pointer, scope, ctx)
         });
         break;
       }
@@ -12908,6 +13062,90 @@ function validateAssignmentTarget(target, scope, ctx) {
     throw new NSGetterRuntimeError(`List index out of bounds: ${index}`);
   }
 }
+function resolvedDestinationFieldsForAssign(target, scope, ctx) {
+  if (target.type !== "keyOf" /* keyOf */) return {};
+  const container = evalPointer(target.keyOf.pointer, scope, ctx);
+  const containerValueId = findKnownRowIdByValueReference(container, ctx);
+  if (containerValueId === null) return {};
+  const key = evalPointer(target.keyOf.key, scope, ctx);
+  if (typeof key !== "string" && typeof key !== "number") return {};
+  return { resolvedDestination: { containerValueId, key } };
+}
+function resolvedDestinationFieldsForContainer(targetValue, ctx) {
+  const containerValueId = findKnownRowIdByValueReference(targetValue, ctx);
+  return containerValueId === null ? {} : { resolvedDestination: { containerValueId } };
+}
+function dispatchNSSetter(target, value, scope, ctx, writes) {
+  if (target.type !== "callGetter" /* callGetter */) {
+    throw new NSGetterRuntimeError(
+      "Setter write target must be a callGetter pointer."
+    );
+  }
+  const receiver = evalPointer(target.thisPointer, scope, ctx);
+  if (receiver === null || receiver === void 0) {
+    throw new NSGetterRuntimeError("Cannot invoke setter on a null receiver.");
+  }
+  const attributeId = resolveEffectiveNSPropertyAttributeId(
+    target.attributeId,
+    receiver,
+    ctx
+  );
+  const stack = ctx.__setterCallStack ?? /* @__PURE__ */ new Set();
+  if (stack.has(attributeId)) {
+    const name = evalAttributeById(ctx.vm, attributeId)?.name ?? attributeId;
+    throw new NSGetterRuntimeError(`Circular setter call: '${name}'.`);
+  }
+  const setter = resolveCompiledSetter(attributeId, ctx.vm.attributes);
+  if (setter === null) {
+    const name = evalAttributeById(ctx.vm, attributeId)?.name ?? attributeId;
+    throw new NSGetterRuntimeError(
+      `NeoScript property '${name}' has no compiled setter \u2014 save its code to compile it.`
+    );
+  }
+  const innerStack = new Set(stack);
+  innerStack.add(attributeId);
+  evaluateNSSetter(
+    setter,
+    {
+      ...ctx,
+      thisValue: receiver,
+      __setterCallStack: innerStack
+    },
+    value,
+    writes
+  );
+}
+function resolveEffectiveNSPropertyAttributeId(staticAttributeId, receiver, ctx) {
+  const placement = findSchemaPlacement(staticAttributeId, ctx.vm.types);
+  if (placement === null) return staticAttributeId;
+  const row = ctx.vm.values.find((candidate) => candidate.value === receiver);
+  if (row === void 0) return staticAttributeId;
+  const runtimeTypeId = customTypeIdForValueRow(row, ctx);
+  if (runtimeTypeId === void 0) return staticAttributeId;
+  let chain;
+  try {
+    chain = resolveInheritanceChain(runtimeTypeId, ctx.vm.types);
+  } catch {
+    return staticAttributeId;
+  }
+  const entry = mergeSchemas(chain).find(
+    (candidate) => candidate.schemaKey === placement.schemaKey
+  );
+  if (entry?.attributeId === null || entry?.attributeId === void 0) {
+    return staticAttributeId;
+  }
+  const effective = evalAttributeById(ctx.vm, entry.attributeId);
+  return effective?.type === 10 /* NSProperty */ ? entry.attributeId : staticAttributeId;
+}
+function resolveCompiledSetter(attributeId, attributes) {
+  const found = walkExtendsAttributeChain(
+    attributeId,
+    attributes,
+    (attribute) => attribute.setter,
+    { requireType: 10 /* NSProperty */ }
+  );
+  return found ?? null;
+}
 function evalCollectionMutationInstruction(ins, scope, ctx, options) {
   const targetValue = evalPointer(ins.target.pointer, scope, ctx);
   const args = ins.args.map((arg) => evalPointer(arg, scope, ctx));
@@ -12929,7 +13167,8 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
         options.writes.push({
           kind: "add",
           target: ins.target,
-          value: isLookupSet ? lookupSetSelectionValue(args[0], ctx) : args[0]
+          value: isLookupSet ? lookupSetSelectionValue(args[0], ctx) : args[0],
+          ...resolvedDestinationFieldsForContainer(targetValue, ctx)
         });
         return;
       }
@@ -12937,7 +13176,8 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
         kind: "add",
         target: ins.target,
         key: String(args[0]),
-        value: args[1]
+        value: args[1],
+        ...resolvedDestinationFieldsForContainer(targetValue, ctx)
       });
       return;
     case "Remove" /* Remove */:
@@ -12945,27 +13185,31 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
         options.writes.push({
           kind: "remove",
           target: ins.target,
-          value: isLookupSet ? lookupSetSelectionValue(args[0], ctx) : args[0]
+          value: isLookupSet ? lookupSetSelectionValue(args[0], ctx) : args[0],
+          ...resolvedDestinationFieldsForContainer(targetValue, ctx)
         });
         return;
       }
       options.writes.push({
         kind: "remove",
         target: ins.target,
-        key: String(args[0])
+        key: String(args[0]),
+        ...resolvedDestinationFieldsForContainer(targetValue, ctx)
       });
       return;
     case "RemoveAt" /* RemoveAt */:
       options.writes.push({
         kind: "remove",
         target: ins.target,
-        index: numberArg(args[0], "RemoveAt index")
+        index: numberArg(args[0], "RemoveAt index"),
+        ...resolvedDestinationFieldsForContainer(targetValue, ctx)
       });
       return;
     case "Clear" /* Clear */:
       options.writes.push({
         kind: "clear",
-        target: ins.target
+        target: ins.target,
+        ...resolvedDestinationFieldsForContainer(targetValue, ctx)
       });
       return;
   }
@@ -13290,9 +13534,8 @@ function dispatchNSGetterById(attributeId, receiver, ctx) {
   const innerStack = new Set(stack);
   innerStack.add(attributeId);
   return evaluateNSGetter(getter, {
-    vm: ctx.vm,
+    ...ctx,
     thisValue: receiver,
-    rootValue: ctx.rootValue,
     __getterCallStack: innerStack
   });
 }
@@ -13301,7 +13544,7 @@ function resolveCompiledGetter(attrId, attributes) {
     attrId,
     attributes,
     (a) => a.getter,
-    { requireType: 10 /* NSGetter */ }
+    { requireType: 10 /* NSProperty */ }
   );
   return found ?? null;
 }
@@ -13441,7 +13684,7 @@ function dispatchSchemaMember(receiver, schemaKey, ctx) {
   if (entry.attributeId === null) return { kind: "no-info" };
   const attr = evalAttributeById(ctx.vm, entry.attributeId);
   if (!attr) return { kind: "no-info" };
-  if (attr.type === 10 /* NSGetter */) {
+  if (attr.type === 10 /* NSProperty */) {
     if (!resolveCompiledGetter(entry.attributeId, ctx.vm.attributes)) {
       return { kind: "no-info" };
     }
@@ -14338,6 +14581,71 @@ function resolveThisType(thisRef, document) {
     `--this "${thisRef}" is not a known type name, type id, or value id.`
   );
 }
+function resolveNSPropertyScriptTarget(attributeRef, document) {
+  if (attributeRef === null) {
+    throw new Error(
+      "Setter mode requires --attribute <id-or-name> so `this` and `value` can be typed."
+    );
+  }
+  const matches = document.attributes.filter(
+    (attribute) => attribute.type === 10 && (attribute.id === attributeRef || attribute.name === attributeRef)
+  );
+  if (matches.length === 0) {
+    throw new Error(
+      `--attribute "${attributeRef}" is not a known NeoScript property id or name.`
+    );
+  }
+  if (matches.length > 1) {
+    throw new Error(
+      `--attribute "${attributeRef}" matches multiple NeoScript properties; pass the stable attribute id.`
+    );
+  }
+  return matches[0];
+}
+function resolveAttributeContainingType(attribute, document) {
+  const attributeId = attribute.id;
+  if (typeof attributeId !== "string") {
+    throw new Error(
+      "Setter mode selected a NeoScript property without a stable id."
+    );
+  }
+  const matches = document.types.filter((type) => {
+    const schema = type.schema;
+    return isObjectRecord2(schema) && Object.values(schema).includes(attributeId);
+  });
+  if (matches.length === 0) {
+    throw new Error(
+      `NeoScript property "${String(attribute.name ?? attributeId)}" is not placed on a custom type.`
+    );
+  }
+  if (matches.length > 1) {
+    throw new Error(
+      `NeoScript property "${String(attribute.name ?? attributeId)}" is placed on multiple custom types; pass a stable override attribute id that identifies one placement.`
+    );
+  }
+  return matches[0];
+}
+function resolveScriptPropertyReturnTypeInfo(attribute, attributes) {
+  let current = attribute;
+  const visited = /* @__PURE__ */ new Set();
+  while (current !== void 0) {
+    if (current.returnTypeInfo !== void 0) {
+      return current.returnTypeInfo;
+    }
+    const parentId = current.extendsAttributeId;
+    if (typeof parentId !== "string") break;
+    if (visited.has(parentId)) {
+      throw new Error(
+        `Cannot resolve NeoScript property return type: circular attribute chain at "${parentId}".`
+      );
+    }
+    visited.add(parentId);
+    current = attributes.find((candidate) => candidate.id === parentId);
+  }
+  throw new Error(
+    `NeoScript property "${String(attribute.name ?? attribute.id)}" has no returnTypeInfo in its base chain.`
+  );
+}
 function resolveThisValue(thisRef, document) {
   if (thisRef === null) return null;
   const value = document.values.find((entry) => entry.id === thisRef);
@@ -14379,7 +14687,18 @@ async function runScript(workspace, command, options) {
     return;
   }
   const source = readSource(options);
-  const thisType = resolveThisType(options.thisRef, document);
+  if (options.mode === "setter" && command !== "check" && command !== "compile") {
+    throw new Error(
+      "Setter mode supports only `neo script check` and `neo script compile` in v1; eval/apply require a concrete receiver and transactional write semantics."
+    );
+  }
+  const setterAttribute = options.mode === "setter" ? resolveNSPropertyScriptTarget(options.attributeRef, document) : null;
+  if (setterAttribute !== null && options.returns !== null) {
+    throw new Error(
+      "Setter mode derives the value type from --attribute; do not pass --returns."
+    );
+  }
+  const thisType = setterAttribute === null ? resolveThisType(options.thisRef, document) : resolveAttributeContainingType(setterAttribute, document);
   const compileContext = {
     project: document.project,
     attributes: document.attributes,
@@ -14391,14 +14710,32 @@ async function runScript(workspace, command, options) {
   };
   let compiled;
   try {
-    compiled = command === "apply" || options.mode === "action" ? compileNSAction(source, compileContext) : compileNSGetter(source, compileContext);
+    if (options.mode === "setter") {
+      if (setterAttribute === null) {
+        throw new Error("Setter mode requires an NSProperty attribute target.");
+      }
+      compiled = compileNSSetter(source, {
+        project: document.project,
+        attributes: document.attributes,
+        types: document.types,
+        enums: document.enums,
+        thisType,
+        valueTypeInfo: resolveScriptPropertyReturnTypeInfo(
+          setterAttribute,
+          document.attributes
+        )
+      });
+    } else {
+      compiled = command === "apply" || options.mode === "action" ? compileNSAction(source, compileContext) : compileNSGetter(source, compileContext);
+    }
   } catch (error) {
     if (error instanceof CompileError) {
       const report2 = {
         ok: false,
         error: error.message,
         line: error.line,
-        column: error.column
+        column: error.column,
+        unit: options.mode === "setter" ? "setter" : void 0
       };
       const hint = options.returns === null && error.message.includes("not assignable to declared return type") ? '\n(eval defaults to an unknown return type \u2014 pass --returns, e.g. --returns "string[]")' : "";
       console.log(
@@ -14556,40 +14893,86 @@ function runCheckAll(document, options) {
   const results = [];
   for (const attribute of document.attributes) {
     if (attribute.type !== 10) continue;
-    if (typeof attribute.code !== "string") continue;
-    checked += 1;
+    if (typeof attribute.code !== "string" && typeof attribute.setterCode !== "string") {
+      continue;
+    }
     const thisType = typeByAttributeId.get(String(attribute.id)) ?? null;
-    try {
-      compileNSGetter(attribute.code, {
-        project: document.project,
-        attributes: document.attributes,
-        types: document.types,
-        enums: document.enums,
-        thisType,
-        returnTypeInfo: attribute.returnTypeInfo ?? RETURN_SHORTHANDS.unknown,
-        dialogueContext: null
+    const context = {
+      project: document.project,
+      attributes: document.attributes,
+      types: document.types,
+      enums: document.enums,
+      thisType,
+      returnTypeInfo: resolveScriptPropertyReturnTypeInfo(
+        attribute,
+        document.attributes
+      ),
+      dialogueContext: null
+    };
+    const checks = [];
+    if (typeof attribute.code === "string") {
+      checks.push({
+        unit: "getter",
+        run: () => {
+          compileNSGetter(attribute.code, context);
+        }
       });
-      results.push({ id: attribute.id, name: attribute.name, ok: true });
-    } catch (error) {
-      failures += 1;
-      const message = error instanceof CompileError ? `${error.line}:${error.column} ${error.message}` : error instanceof Error ? error.message : String(error);
-      results.push({
-        id: attribute.id,
-        name: attribute.name,
-        ok: false,
-        error: message
+    }
+    if (typeof attribute.setterCode === "string") {
+      checks.push({
+        unit: "setter",
+        run: () => {
+          compileNSSetter(
+            attribute.setterCode,
+            {
+              project: document.project,
+              attributes: document.attributes,
+              types: document.types,
+              enums: document.enums,
+              thisType,
+              valueTypeInfo: resolveScriptPropertyReturnTypeInfo(
+                attribute,
+                document.attributes
+              )
+            }
+          );
+        }
       });
-      if (!options.json) {
-        console.log(
-          `FAIL ${String(attribute.name)} (${String(attribute.id)}): ${message}`
-        );
+    }
+    for (const check of checks) {
+      checked += 1;
+      try {
+        check.run();
+        results.push({
+          id: attribute.id,
+          name: attribute.name,
+          unit: check.unit,
+          ok: true
+        });
+      } catch (error) {
+        failures += 1;
+        const message = error instanceof CompileError ? `${error.line}:${error.column} ${error.message}` : error instanceof Error ? error.message : String(error);
+        results.push({
+          id: attribute.id,
+          name: attribute.name,
+          unit: check.unit,
+          ok: false,
+          error: message
+        });
+        if (!options.json) {
+          console.log(
+            `FAIL ${String(attribute.name)} (${String(attribute.id)}) [${check.unit}]: ${message}`
+          );
+        }
       }
     }
   }
   if (options.json) {
     console.log(JSON.stringify({ checked, failures, results }, null, 2));
   } else {
-    console.log(`${checked} getter(s) checked, ${failures} failure(s).`);
+    console.log(
+      `${checked} property body/bodies checked, ${failures} failure(s).`
+    );
   }
   if (failures > 0) process.exitCode = 1;
 }
@@ -14837,6 +15220,17 @@ function resolveWriteTarget(write, env, migrationName) {
       `Migration "${migrationName}" produced a "${write.kind}" collection mutation; the runner applies scalar assignments only (creating/deleting value records is not yet supported).`
     );
   }
+  const resolved = write.resolvedDestination;
+  if (resolved !== void 0 && resolved.key !== void 0) {
+    const container2 = env.valueById.get(resolved.containerValueId)?.value;
+    const leaf2 = Array.isArray(container2) && typeof resolved.key === "number" ? container2[resolved.key] : isObjectRecord2(container2) ? container2[String(resolved.key)] : void 0;
+    if (typeof leaf2 !== "string") {
+      throw new Error(
+        `Migration "${migrationName}" resolved its assignment to container "${resolved.containerValueId}", but key "${String(resolved.key)}" has no stored value id.`
+      );
+    }
+    return { leafValueId: leaf2 };
+  }
   const target = write.target;
   if (!isObjectRecord2(target) || !isObjectRecord2(target.pointer)) {
     throw new Error(
@@ -14920,6 +15314,11 @@ function resolveContainerMap(pointer, env, migrationName) {
   );
 }
 function resolveCollectionTarget(write, env, migrationName) {
+  if (write.resolvedDestination !== void 0) {
+    return {
+      containerValueId: write.resolvedDestination.containerValueId
+    };
+  }
   const target = isObjectRecord2(write.target) ? write.target : {};
   const pointer = isObjectRecord2(target.pointer) ? target.pointer : {};
   if (pointer.type === "keyOf" && isObjectRecord2(pointer.keyOf)) {
@@ -15526,7 +15925,7 @@ async function runBranch(workspace, subcommand, positional, fromRef) {
     success(
       `Switched to ${color.bold(displayLabel(target))} ${color.dim(`(${target.id})`)}. Pulling\u2026`
     );
-    await runPull(workspace, { force: true });
+    await runPull(workspace, { force: true, reset: false });
     return;
   }
   if (subcommand === "delete") {
@@ -15758,7 +16157,7 @@ async function runMerge(workspace, sourceRef, dryRun, runMigrations = false) {
     }
     if (merged > 0) {
       console.log("Pulling merged state...");
-      await runPull(workspace, { force: false });
+      await runPull(workspace, { force: false, reset: false });
     }
     if (runMigrations) {
       const { runMigrate: runMigrate2 } = await Promise.resolve().then(() => (init_migrate(), migrate_exports));
@@ -16640,7 +17039,13 @@ function checkWriteOwnership(write, compiledAction, label, ctx, world, violate)
     );
     return;
   }
-  const rowId = resolveWriteRowId(target, compiledAction, ctx, world);
+  const rowId = resolveWriteRowId(
+    write,
+    target,
+    compiledAction,
+    ctx,
+    world
+  );
   if (rowId === null) {
     violate(
       label,
@@ -16690,7 +17095,15 @@ function targetLiteralKey(target) {
   if (!isObjectRecord2(key) || !isObjectRecord2(key.value)) return null;
   return typeof key.value.value === "string" ? key.value.value : null;
 }
-function resolveWriteRowId(target, compiledAction, ctx, world) {
+function resolveWriteRowId(write, target, compiledAction, ctx, world) {
+  const resolved = write.resolvedDestination;
+  if (resolved !== void 0) {
+    if (write.kind !== "assign") return resolved.containerValueId;
+    if (resolved.key === void 0) return null;
+    const container = world.valueById.get(resolved.containerValueId)?.value;
+    const leaf = Array.isArray(container) && typeof resolved.key === "number" ? container[resolved.key] : isObjectRecord2(container) ? container[String(resolved.key)] : void 0;
+    return typeof leaf === "string" && world.valueById.has(leaf) ? leaf : null;
+  }
   const pointer = isObjectRecord2(target.pointer) ? target.pointer : target;
   const evalPointer2 = (p) => {
     const getter = {
@@ -17898,6 +18311,7 @@ var init_export = __esm({
 // src/commands/push.ts
 var push_exports = {};
 __export(push_exports, {
+  prepareNSPropertySetterChanges: () => prepareNSPropertySetterChanges,
   rewriteFilesFromState: () => rewriteFilesFromState,
   runPush: () => runPush
 });
@@ -17962,6 +18376,7 @@ ${status.parseErrors.map((error) => `  ${error.message}`).join("\n")}`
     console.log("Nothing to push \u2014 working copy is clean.");
     return;
   }
+  prepareNSPropertySetterChanges(workspace, status);
   assignPendingIds(status.changes);
   const now = Date.now();
   for (const change of status.changes) {
@@ -17972,15 +18387,12 @@ ${status.parseErrors.map((error) => `  ${error.message}`).join("\n")}`
         action: compileMigrationAction(status, change.nextData)
       };
     }
-    if (change.recordKind === "attribute" && change.nextData.type === 10 && typeof change.nextData.code === "string" && change.nextData.code.trim().length > 0) {
-      change.nextData = {
-        ...change.nextData,
-        getter: await compileAttributeGetter(
-          workspace,
-          status,
-          change.nextData
-        )
-      };
+    if (change.recordKind === "attribute" && change.nextData.type === 10) {
+      change.nextData = await compileNSPropertyChange(
+        workspace,
+        status,
+        change.nextData
+      );
     }
     if (change.kind === "create") {
       change.nextData = {
@@ -18191,7 +18603,7 @@ function rewriteFilesFromState(workspace) {
     workspace.state.records[key] = nextState;
   }
 }
-async function compileAttributeGetter(workspace, status, attributeData) {
+async function compileNSPropertyChange(workspace, status, attributeData) {
   const types = [];
   const attributes = [];
   const enums = [];
@@ -18208,17 +18620,170 @@ async function compileAttributeGetter(workspace, status, attributeData) {
   }) ?? null;
   const { raw } = await fetchProjectDocument(workspace);
   if (typeof raw.project !== "object" || raw.project === null) {
-    throw new Error("Cannot compile getter: project record is unavailable.");
+    throw new Error(
+      "Cannot compile NeoScript property: project record is unavailable."
+    );
+  }
+  const returnTypeInfo = resolveNSPropertyReturnTypeInfo(
+    attributeData,
+    attributes
+  );
+  const next = { ...attributeData };
+  if (typeof attributeData.code === "string") {
+    next.getter = compileNSGetter(attributeData.code, {
+      project: raw.project,
+      attributes,
+      types,
+      enums,
+      thisType,
+      returnTypeInfo,
+      dialogueContext: null
+    });
+  } else {
+    delete next.getter;
+  }
+  if (typeof attributeData.setterCode === "string") {
+    next.setter = compileNSSetter(attributeData.setterCode, {
+      project: raw.project,
+      attributes,
+      types,
+      enums,
+      thisType,
+      valueTypeInfo: returnTypeInfo
+    });
+  } else {
+    delete next.setter;
+  }
+  return next;
+}
+function prepareNSPropertySetterChanges(workspace, status) {
+  const attributes = /* @__PURE__ */ new Map();
+  for (const record of status.reconstructed.values()) {
+    if (record.recordKind !== "attribute") continue;
+    if (typeof record.fullData.id !== "string") continue;
+    attributes.set(record.fullData.id, record.fullData);
+  }
+  const changesById = /* @__PURE__ */ new Map();
+  for (const change of status.changes) {
+    if (change.recordKind !== "attribute") continue;
+    changesById.set(change.recordId, change);
+    if (change.nextData === void 0) continue;
+    if (change.nextData.type === 10) {
+      if (typeof change.nextData.code !== "string") {
+        delete change.nextData.getter;
+      }
+      if (typeof change.nextData.setterCode !== "string") {
+        delete change.nextData.setter;
+      }
+    }
+    attributes.set(change.recordId, change.nextData);
+  }
+  const removedDeclarations = status.changes.filter(
+    (change) => change.recordKind === "attribute" && change.nextData?.type === 10 && isObjectRecord2(change.baseData) && typeof change.baseData.setterCode === "string" && typeof change.nextData.setterCode !== "string" && !ancestorDeclaresSetter(change.nextData, attributes)
+  ).map((change) => change.recordId);
+  for (const declarationId of removedDeclarations) {
+    for (const [attributeId, attribute] of attributes) {
+      if (attributeId === declarationId) continue;
+      if (!attributeDescendsFrom(attribute, declarationId, attributes)) {
+        continue;
+      }
+      if (typeof attribute.setterCode !== "string" && attribute.setter === void 0) {
+        continue;
+      }
+      const next = { ...attribute };
+      delete next.setterCode;
+      delete next.setter;
+      attributes.set(attributeId, next);
+      const key = recordStateKey("attribute", attributeId);
+      const reconstructed = status.reconstructed.get(key);
+      if (reconstructed !== void 0) reconstructed.fullData = next;
+      const existingChange = changesById.get(attributeId);
+      if (existingChange !== void 0) {
+        existingChange.nextData = next;
+        continue;
+      }
+      const base = workspace.state.records[key];
+      if (base === void 0 || reconstructed === void 0) {
+        throw new Error(
+          `Cannot cascade removal of NeoScript property setter to override "${attributeId}": its working-copy state is missing.`
+        );
+      }
+      const cascadeChange = {
+        kind: "update",
+        recordKind: "attribute",
+        recordId: attributeId,
+        file: reconstructed.file,
+        nextData: next,
+        baseData: base.data,
+        baseContentHash: base.contentHash,
+        casBaseHash: base.conflictServerHash ?? base.contentHash
+      };
+      status.changes.push(cascadeChange);
+      changesById.set(attributeId, cascadeChange);
+    }
+  }
+  for (const attribute of attributes.values()) {
+    if (attribute.type !== 10) continue;
+    if (typeof attribute.extendsAttributeId !== "string") continue;
+    if (typeof attribute.setterCode !== "string") continue;
+    if (ancestorDeclaresSetter(attribute, attributes)) continue;
+    throw new Error(
+      `Override NeoScript property "${String(attribute.name ?? attribute.id)}" cannot add a setter because its base chain does not declare one.`
+    );
   }
-  return compileNSGetter(String(attributeData.code), {
-    project: raw.project,
-    attributes,
-    types,
-    enums,
-    thisType,
-    returnTypeInfo: attributeData.returnTypeInfo,
-    dialogueContext: null
-  });
+}
+function ancestorDeclaresSetter(attribute, attributes) {
+  let parentId = typeof attribute.extendsAttributeId === "string" ? attribute.extendsAttributeId : null;
+  const visited = /* @__PURE__ */ new Set();
+  while (parentId !== null) {
+    if (visited.has(parentId)) {
+      throw new Error(
+        `Cannot resolve NeoScript property setter inheritance: circular attribute chain at "${parentId}".`
+      );
+    }
+    visited.add(parentId);
+    const parent = attributes.get(parentId);
+    if (parent === void 0) {
+      throw new Error(
+        `Cannot resolve NeoScript property setter inheritance: missing parent attribute "${parentId}".`
+      );
+    }
+    if (typeof parent.setterCode === "string") return true;
+    parentId = typeof parent.extendsAttributeId === "string" ? parent.extendsAttributeId : null;
+  }
+  return false;
+}
+function attributeDescendsFrom(attribute, ancestorId, attributes) {
+  let parentId = typeof attribute.extendsAttributeId === "string" ? attribute.extendsAttributeId : null;
+  const visited = /* @__PURE__ */ new Set();
+  while (parentId !== null) {
+    if (parentId === ancestorId) return true;
+    if (visited.has(parentId)) return false;
+    visited.add(parentId);
+    const parent = attributes.get(parentId);
+    if (parent === void 0) return false;
+    parentId = typeof parent.extendsAttributeId === "string" ? parent.extendsAttributeId : null;
+  }
+  return false;
+}
+function resolveNSPropertyReturnTypeInfo(attribute, attributes) {
+  let current = attribute;
+  const visited = /* @__PURE__ */ new Set();
+  while (current !== void 0) {
+    if (current.returnTypeInfo !== void 0) return current.returnTypeInfo;
+    const parentId = current.extendsAttributeId;
+    if (typeof parentId !== "string") break;
+    if (visited.has(parentId)) {
+      throw new Error(
+        `Cannot compile NeoScript property "${String(attribute.id)}": circular attribute inheritance at "${parentId}".`
+      );
+    }
+    visited.add(parentId);
+    current = attributes.find((candidate) => candidate.id === parentId);
+  }
+  throw new Error(
+    `Cannot compile NeoScript property "${String(attribute.id)}": its returnTypeInfo could not be resolved from the base chain.`
+  );
 }
 function compileMigrationAction(status, migrationData) {
   const types = [];
@@ -18301,7 +18866,7 @@ async function runDev(workspace, options) {
     try {
       refreshState();
       console.log(`[dev] ${label} \u2014 pulling...`);
-      await runPull(workspace, { force: false });
+      await runPull(workspace, { force: false, reset: false });
       if (pendingSignalHash !== null) {
         workspace.state.headTransactionHash = pendingSignalHash;
         lastSeenHash = pendingSignalHash;
@@ -18635,11 +19200,7 @@ async function runWhoami(apiBaseUrl) {
   console.log(`Signed in as ${name} <${email}> at ${apiBaseUrl}`);
 }
 
-// src/main.ts
-init_status();
-init_workspace();
-init_ui();
-var DEFAULT_API_BASE_URL = "http://localhost:3000";
+// src/args.ts
 var BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   "dry-run",
   "json",
@@ -18655,7 +19216,52 @@ var BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   "migrate",
   "server",
   "replace",
-  "generate-ids"
+  "reset",
+  "generate-ids",
+  "help"
+]);
+var KNOWN_FLAGS = /* @__PURE__ */ new Set([
+  "accept-bump",
+  "all",
+  "api",
+  "attribute",
+  "bump",
+  "commit",
+  "dir",
+  "dry-run",
+  "entries",
+  "file",
+  "force",
+  "from",
+  "generate-ids",
+  "help",
+  "into",
+  "json",
+  "key",
+  "kind",
+  "migrate",
+  "mine",
+  "mode",
+  "out",
+  "profile",
+  "project",
+  "push",
+  "replace",
+  "reset",
+  "returns",
+  "save",
+  "save-project",
+  "server",
+  "skip-invalid",
+  "status",
+  "summary",
+  "target",
+  "template",
+  "theirs",
+  "this",
+  "token-stdin",
+  "type",
+  "version"
 ]);
 function parseArgs(argv) {
   const [command = null, ...rest] = argv;
@@ -18689,6 +19295,19 @@ function stringFlag(args, name) {
 function boolFlag(args, name) {
   return args.flags.get(name) === true;
 }
+function assertKnownFlags(args) {
+  for (const name of args.flags.keys()) {
+    if (KNOWN_FLAGS.has(name)) continue;
+    const hint = args.command === null ? "Run `neo help` for usage." : `Run \`neo ${args.command} --help\` for usage.`;
+    throw new Error(`Unknown flag "--${name}". ${hint}`);
+  }
+}
+
+// src/main.ts
+init_status();
+init_workspace();
+init_ui();
+var DEFAULT_API_BASE_URL = "http://localhost:3000";
 function profileFlag(args) {
   const value = stringFlag(args, "profile");
   if (value === null) return null;
@@ -18717,7 +19336,7 @@ ${h("Start")}
   whoami    ${d("[--api <url>]")}
 
 ${h("Working copy")}
-  pull      ${d("[--force]")}                 push    ${d("[--dry-run] [--summary <text>] [--accept-bump]")}
+  pull      ${d("[--force|--reset]")}         push    ${d("[--dry-run] [--summary <text>] [--accept-bump]")}
   status    ${d("[--json]")}                  diff    ${d("[--json]")}
   dev       ${d("[--push]")}                  resolve ${d("[--mine|--theirs]")}
 
@@ -18731,13 +19350,58 @@ ${h("Content & scripts")}
   values    ${d("list | get | set | create | delete | ...")}          loc       ${d("locales | list | set | archive | restore | ...")}
   dialogue  ${d("list | show | node | group | priority-group")}
   records   ${d("get | query")}               files     ${d("list | delete")}
-  script    ${d("check | eval | apply")}      migrate   ${d("new | list | check | run | prune")}
+  script    ${d("check | eval | apply | compile [--mode getter|action|setter] [--attribute <id-or-name>]")}
+  migrate   ${d("new | list | check | run | prune")}
 
 Run any command with missing arguments in a terminal and ${h("neo")} will ask.
 `;
 }
+function commandHelp(command) {
+  const h = color.bold;
+  const d = color.dim;
+  if (command === "pull") {
+    return `${h("neo pull")} \u2014 synchronize the schema working copy
+
+${h("Usage")}
+  neo pull ${d("[--force|--reset]")}
+
+${h("Flags")}
+  --force  ${d("Discard local edits and take the current server schema.")}
+  --reset  ${d("Destructively regenerate the entire working copy and schema marker scaffold, even when the sync head is unchanged.")}
+
+Use ${h("--reset")} for schema-vocabulary upgrades such as NeoGetter \u2192
+NeoProperty. It does not attempt to parse the old generated marker files.
+`;
+  }
+  if (command === "push") {
+    return `${h("neo push")} \u2014 commit the working copy to the server
+
+${h("Usage")}
+  neo push ${d("[--dry-run] [--summary <text>] [--accept-bump]")}
+
+${h("Flags")}
+  --dry-run         ${d("Preview the change set; commit nothing.")}
+  --summary <text>  ${d("Attach a summary message to the transaction.")}
+  --accept-bump     ${d("Accept a server-required version bump instead of aborting.")}
+
+Push sends the ${h("entire")} working copy as one atomic compare-and-swap
+transaction. Run ${h("neo status")} / ${h("neo diff")} first \u2014 local-ahead changes
+you did not make this session ride along too.
+`;
+  }
+  return usage();
+}
 async function main() {
   const args = parseArgs(process.argv.slice(2));
+  if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {
+    console.log(usage());
+    return;
+  }
+  if (boolFlag(args, "help")) {
+    console.log(commandHelp(args.command));
+    return;
+  }
+  assertKnownFlags(args);
   const apiBaseUrl = stringFlag(args, "api") ?? DEFAULT_API_BASE_URL;
   switch (args.command) {
     case "login":
@@ -18766,7 +19430,10 @@ async function main() {
     case "pull": {
       const workspace = loadWorkspaceForCommand(args);
       const { runPull: runPull2 } = await Promise.resolve().then(() => (init_pull(), pull_exports));
-      await runPull2(workspace, { force: boolFlag(args, "force") });
+      await runPull2(workspace, {
+        force: boolFlag(args, "force"),
+        reset: boolFlag(args, "reset")
+      });
       return;
     }
     case "branch": {
@@ -18935,11 +19602,18 @@ async function main() {
         );
       }
       const { runScript: runScript2 } = await Promise.resolve().then(() => (init_script(), script_exports));
+      const requestedMode = stringFlag(args, "mode") ?? "getter";
+      if (requestedMode !== "getter" && requestedMode !== "action" && requestedMode !== "setter") {
+        throw new Error(
+          `--mode must be getter, action, or setter; received "${requestedMode}".`
+        );
+      }
       await runScript2(workspace, sub, {
-        mode: stringFlag(args, "mode") === "action" ? "action" : "getter",
+        mode: requestedMode,
         source: args.positional[1] ?? null,
         file: stringFlag(args, "file"),
         thisRef: stringFlag(args, "this"),
+        attributeRef: stringFlag(args, "attribute"),
         returns: stringFlag(args, "returns"),
         all: boolFlag(args, "all"),
         json: boolFlag(args, "json"),
@@ -19089,10 +19763,6 @@ async function main() {
       }
       return;
     }
-    case null:
-    case "help":
-      console.log(usage());
-      return;
     default:
       console.error(`Unknown command "${args.command}".
 `);