@neocompose/cli 0.34.2 → 0.35.0

package/CHANGELOG.md

@@ -1,5 +1,38 @@
 # Changelog
 
+## [0.35.0] - 2026-08-19
+
+### Added
+
+- P72 expression bodies: write `=> expr;` wherever a body is a single
+  expression — getter-only properties (`bool HasVisited => this.Count > 0;`),
+  an accessor inside a property block (`get => ...;`, `set(int value) => ...;`),
+  functions (`bool Ready(int level) => this.Level >= level;`), and lambdas
+  (`(x) => x * 2`). It is pure sugar: the desugared block compiles to the same
+  instruction stream, and diagnostics point at the authored expression. In a
+  void context the expression is a statement, so it must call or assign; an
+  expression whose value would be discarded is refused with a diagnostic that
+  names the block body as the fix.
+- The `=>` reads as an expression body only where it directly follows a member
+  name or a parameter list's `)`, so a NeoFlow destination arrow after an `=`
+  initializer (`override Trigger Trigger = new(...) => Welcome;`) is unchanged.
+
+### Changed
+
+- `neo pull` and `neo push` canonicalize a stored body to `=> expr;` when its
+  authored spelling is exactly one `return` statement that fits on one line;
+  every other body, and every setter, re-emits as a block. A push preserves the
+  form already on disk for members it did not otherwise rewrite, so authoring a
+  one-line getter in longhand stays byte-identical through a push.
+
+### Fixed
+
+- VS Code highlighting no longer claims the identifier after every `=>` as a
+  NeoFlow destination. The destination scope now requires the NeoFlow shape —
+  an arrow after `)`, a single non-keyword identifier, then `;` — so calls,
+  `this.` chains, types, and `get`/`set` keywords inside expression bodies keep
+  their own scopes.
+
 ## [0.34.2] - 2026-08-19
 
 ### Fixed

package/dist/neo.mjs

@@ -3293,7 +3293,13 @@ function insideLambdaBlock(tokens, catchBodyStart, offset) {
       continue;
     }
     const open = significant[index + 1];
-    if (open?.kind !== "punctuation" || open.text !== "{") continue;
+    if (open === void 0) continue;
+    if (open.kind !== "punctuation" || open.text !== "{") {
+      if (open.start <= offset && offset <= lambdaExpressionEnd(significant, index + 1)) {
+        return true;
+      }
+      continue;
+    }
     const closeIndex = matchingCloseBraceIndex(significant, index + 1);
     const close = closeIndex === null ? void 0 : significant[closeIndex];
     if (open.end <= offset && (close === void 0 || offset <= close.start)) {
@@ -3302,6 +3308,23 @@ function insideLambdaBlock(tokens, catchBodyStart, offset) {
   }
   return false;
 }
+function lambdaExpressionEnd(tokens, firstIndex) {
+  let depth = 0;
+  let end = tokens[firstIndex]?.end ?? 0;
+  for (let index = firstIndex; index < tokens.length; index++) {
+    const token = tokens[index];
+    if (!token) break;
+    if (token.kind === "punctuation") {
+      if (["(", "[", "{"].includes(token.text)) depth++;
+      else if ([")", "]", "}"].includes(token.text)) {
+        if (depth === 0) return end;
+        depth--;
+      } else if (token.text === ";" && depth === 0) return end;
+    }
+    end = token.end;
+  }
+  return end;
+}
 function matchingCloseBraceIndex(tokens, openIndex) {
   let depth = 0;
   for (let index = openIndex; index < tokens.length; index++) {
@@ -5076,14 +5099,16 @@ function parseUnits(tokens, pairs, kind, lexed) {
       }
     ];
   }
+  const shorthand = propertyShorthandUnit(tokens, pairs, lexed);
+  if (shorthand) return [shorthand];
   const units = [];
   const candidates = [];
   for (let index = 0; index < tokens.length; index++) {
     const token = tokens[index];
     if (!token) continue;
     if (token.kind === "identifier" && (token.text === "get" || token.text === "set") && isAccessorHeader(token, lexed)) {
-      const openIndex = accessorOpenBraceIndex(tokens, pairs, index);
-      if (openIndex !== null) candidates.push({ tokenIndex: index, openIndex });
+      const open = accessorBodyOpen(tokens, pairs, index);
+      if (open) candidates.push({ tokenIndex: index, ...open });
     }
   }
   for (let candidateIndex = 0; candidateIndex < candidates.length; candidateIndex++) {
@@ -5093,6 +5118,18 @@ function parseUnits(tokens, pairs, kind, lexed) {
     const open = tokens[candidate.openIndex];
     if (!token || !open) continue;
     const nextCandidate = candidates[candidateIndex + 1];
+    if (candidate.expressionBody) {
+      const unit = expressionBodyUnit(
+        tokens,
+        pairs,
+        lexed,
+        token,
+        candidate.openIndex,
+        nextCandidate?.tokenIndex ?? tokens.length
+      );
+      if (unit) units.push(unit);
+      continue;
+    }
     const protectedCloseIndex = findProtectedRegionClose(
       tokens,
       candidate.openIndex,
@@ -5122,15 +5159,70 @@ function isAccessorHeader(token, lexed) {
   const line = lexed.source.lineText(token.range.start.line);
   return line.slice(0, token.range.start.character).trim().length === 0;
 }
-function accessorOpenBraceIndex(tokens, pairs, accessorIndex) {
-  const next = tokens[accessorIndex + 1];
-  if (next?.kind !== "punctuation") return null;
-  if (next.text === "{") return accessorIndex + 1;
-  if (next.text !== "(") return null;
-  const closeParen = pairs.get(accessorIndex + 1);
-  if (closeParen === void 0) return null;
-  const openBrace = tokens[closeParen + 1];
-  return openBrace?.kind === "punctuation" && openBrace.text === "{" ? closeParen + 1 : null;
+function accessorBodyOpen(tokens, pairs, accessorIndex) {
+  let openIndex = accessorIndex + 1;
+  if (tokens[openIndex]?.text === "(") {
+    const closeParen = pairs.get(openIndex);
+    if (closeParen === void 0) return null;
+    openIndex = closeParen + 1;
+  }
+  const open = tokens[openIndex];
+  if (open?.kind === "punctuation" && open.text === "{") {
+    return { openIndex, expressionBody: false };
+  }
+  if (open?.kind === "operator" && open.text === "=>") {
+    return { openIndex, expressionBody: true };
+  }
+  return null;
+}
+function expressionBodyUnit(tokens, pairs, lexed, keyword, arrowIndex, limit) {
+  const first = tokens[arrowIndex + 1];
+  if (!first || first.text === ";") return null;
+  const end = expressionBodyEnd(tokens, pairs, arrowIndex + 1, limit);
+  if (end.bodyEnd <= first.start) return null;
+  return {
+    kind: keyword.text === "get" ? "getter" : "setter",
+    range: lexed.source.range(keyword.start, end.unitEnd),
+    bodyRange: lexed.source.range(first.start, end.bodyEnd),
+    bodyStart: first.start,
+    bodyEnd: end.bodyEnd,
+    expressionBody: true
+  };
+}
+function propertyShorthandUnit(tokens, pairs, lexed) {
+  const arrow = tokens[0];
+  if (arrow?.kind !== "operator" || arrow.text !== "=>") return null;
+  const first = tokens[1];
+  if (!first) return null;
+  const end = expressionBodyEnd(tokens, pairs, 1, tokens.length);
+  if (end.bodyEnd <= first.start) return null;
+  return {
+    kind: "getter",
+    range: lexed.source.range(arrow.start, end.unitEnd),
+    bodyRange: lexed.source.range(first.start, end.bodyEnd),
+    bodyStart: first.start,
+    bodyEnd: end.bodyEnd,
+    expressionBody: true
+  };
+}
+function expressionBodyEnd(tokens, pairs, firstIndex, limit) {
+  let last = tokens[firstIndex];
+  for (let cursor = firstIndex; cursor < limit; cursor++) {
+    const token = tokens[cursor];
+    if (!token) break;
+    if (token.text === ";") {
+      return { bodyEnd: last.end, unitEnd: token.end };
+    }
+    if (token.text === "}") return { bodyEnd: last.end, unitEnd: last.end };
+    const close = OPEN_TO_CLOSE.has(token.text) ? pairs.get(cursor) : void 0;
+    if (close !== void 0 && close < limit) {
+      cursor = close;
+      last = tokens[close] ?? last;
+      continue;
+    }
+    last = token;
+  }
+  return { bodyEnd: last.end, unitEnd: last.end };
 }
 function findProtectedRegionClose(tokens, openIndex, indentation, limit) {
   for (let index = openIndex + 1; index < limit; index++) {
@@ -5386,8 +5478,8 @@ function validatePropertyUnits(units, diagnostics, lexed) {
       severity: "error",
       source: "neoscript",
       code: "missing-getter",
-      message: "A NeoScript property sidecar must declare one `get { ... }` unit.",
-      suggestions: ["Add `get { return ...; }`."]
+      message: "A NeoScript property sidecar must declare one `get { ... }` or `get => ...;` unit.",
+      suggestions: ["Add `get => ...;` or `get { return ...; }`."]
     });
   }
   if (getters.length > 1) duplicateUnitDiagnostic("get", getters, diagnostics);
@@ -5933,6 +6025,60 @@ var init_strict_compile_error = __esm({
   }
 });
 
+// ../packages/neoscript-language/src/strict-ast.ts
+function expressionBodyStatements(body, voidContext) {
+  const pos = body.start;
+  if (body.assignment) {
+    return [
+      {
+        kind: "assign",
+        target: body.expr,
+        op: body.assignment.op,
+        value: body.assignment.value,
+        pos
+      }
+    ];
+  }
+  if (voidContext) {
+    return [{ kind: "exprStmt", expr: body.expr, pos, expressionBody: true }];
+  }
+  return [{ kind: "return", expr: body.expr, pos }];
+}
+function collectReturnStatements(statements) {
+  const result = [];
+  for (const statement of statements) {
+    if (statement.kind === "return") result.push(statement);
+    if (statement.kind === "if") {
+      for (const branch of statement.branches) {
+        result.push(...collectReturnStatements(branch.body));
+      }
+      if (statement.elseBody) {
+        result.push(...collectReturnStatements(statement.elseBody));
+      }
+    }
+    if (statement.kind === "for" || statement.kind === "forEach") {
+      result.push(...collectReturnStatements(statement.body));
+    }
+    if (statement.kind === "switch") {
+      for (const section of statement.sections) {
+        result.push(...collectReturnStatements(section.body));
+      }
+    }
+    if (statement.kind === "try") {
+      result.push(...collectReturnStatements(statement.body));
+      for (const clause of statement.catches) {
+        result.push(...collectReturnStatements(clause.body));
+      }
+    }
+  }
+  return result;
+}
+var init_strict_ast = __esm({
+  "../packages/neoscript-language/src/strict-ast.ts"() {
+    "use strict";
+  }
+});
+
 // ../packages/neoscript-language/src/project-source-identifiers.ts
 function isValidNeoProjectIdentifier(name) {
   return PROJECT_IDENTIFIER_PATTERN.test(name) && !PROJECT_RESERVED_NAMES.has(name);
@@ -6486,6 +6632,17 @@ function parseFunctionBody(source) {
     pos: tokens[0]?.pos ?? { line: 1, column: 1 }
   };
 }
+function parseExpressionBody(source) {
+  const tokens = lex2(source);
+  const parser = new Parser(tokens);
+  const expressionBody = parser.parseExpressionBodyTail();
+  parser.expect("eof");
+  return {
+    body: expressionBodyStatements(expressionBody, false),
+    pos: expressionBody.start,
+    expressionBody
+  };
+}
 function parseExpression(source) {
   const parser = new Parser(lex2(source));
   const expression = parser.parseExpr();
@@ -6535,6 +6692,7 @@ var Parser;
 var init_strict_parser = __esm({
   "../packages/neoscript-language/src/strict-parser.ts"() {
     "use strict";
+    init_strict_ast();
     init_strict_compile_error();
     init_language_spec();
     init_project_source_identifiers();
@@ -7651,6 +7809,16 @@ var init_strict_parser = __esm({
         }
         this.expect("punct", ")");
         this.expect("op", "=>");
+        if (!(this.peek().kind === "punct" && this.peek().text === "{")) {
+          const expressionBody = this.parseExpressionBodyTail();
+          return {
+            kind: "lambda",
+            params,
+            body: expressionBodyStatements(expressionBody, false),
+            pos: startPos,
+            expressionBody
+          };
+        }
         this.expect("punct", "{");
         const body = this.parseStatementList(false);
         this.expect("punct", "}");
@@ -7661,6 +7829,46 @@ var init_strict_parser = __esm({
           pos: startPos
         };
       }
+      /**
+       * Parses the body of an expression-bodied lambda or member — everything
+       * after `=>`, stopping before any terminator the caller owns.
+       *
+       * Assignment and increment operators are accepted here because NeoScript
+       * models them as statements rather than expressions; that is what makes
+       * `set(int value) => _field = value` expressible. The resolver rejects the
+       * assignment form wherever the unit has to produce a value.
+       */
+      parseExpressionBodyTail() {
+        const start = this.peek().pos;
+        if (isIncrementOp(this.peek())) {
+          const opTok = this.next();
+          const target = this.parseExpr();
+          return this.expressionBody(start, target, {
+            op: opTok.text,
+            value: null
+          });
+        }
+        const expr = this.parseExpr();
+        if (isIncrementOp(this.peek())) {
+          const opTok = this.next();
+          return this.expressionBody(start, expr, {
+            op: opTok.text,
+            value: null
+          });
+        }
+        if (isAssignmentOp(this.peek())) {
+          const opTok = this.next();
+          return this.expressionBody(start, expr, {
+            op: opTok.text,
+            value: this.parseExpr()
+          });
+        }
+        return this.expressionBody(start, expr, null);
+      }
+      /** Closes an expression body at the token the parser has not consumed. */
+      expressionBody(start, expr, assignment) {
+        return { expr, assignment, start, end: this.peek().pos };
+      }
       /**
        * Parses a single lambda parameter. Supports:
        *   - `name`            (untyped — resolver infers from receiver)
@@ -7738,42 +7946,6 @@ var init_strict_parser = __esm({
   }
 });
 
-// ../packages/neoscript-language/src/strict-ast.ts
-function collectReturnStatements(statements) {
-  const result = [];
-  for (const statement of statements) {
-    if (statement.kind === "return") result.push(statement);
-    if (statement.kind === "if") {
-      for (const branch of statement.branches) {
-        result.push(...collectReturnStatements(branch.body));
-      }
-      if (statement.elseBody) {
-        result.push(...collectReturnStatements(statement.elseBody));
-      }
-    }
-    if (statement.kind === "for" || statement.kind === "forEach") {
-      result.push(...collectReturnStatements(statement.body));
-    }
-    if (statement.kind === "switch") {
-      for (const section of statement.sections) {
-        result.push(...collectReturnStatements(section.body));
-      }
-    }
-    if (statement.kind === "try") {
-      result.push(...collectReturnStatements(statement.body));
-      for (const clause of statement.catches) {
-        result.push(...collectReturnStatements(clause.body));
-      }
-    }
-  }
-  return result;
-}
-var init_strict_ast = __esm({
-  "../packages/neoscript-language/src/strict-ast.ts"() {
-    "use strict";
-  }
-});
-
 // ../packages/neoscript-language/src/declared-constructors.ts
 function neoScriptArgumentNameSetKey(names) {
   return [...names].map((name) => name.toLowerCase()).sort().join(",");
@@ -9095,6 +9267,9 @@ function typesOverlap(left, right, project) {
 function isUnknown(type) {
   return type.kind === "primitive" && type.name === "unknown";
 }
+function describeUnitKind(kind) {
+  return kind === "function" ? "NSFunction" : kind;
+}
 function isVoid(type) {
   return type?.kind === "primitive" && type.name === "void";
 }
@@ -9769,7 +9944,12 @@ var init_strict_resolver = __esm({
         );
         this.expectedReturnStack.push(returnType);
         try {
-          const instructions = this.resolveStatements(body.body, scope);
+          const statements = this.expressionBodyOrBlock(
+            body,
+            this.context.kind === "action" || this.context.kind === "setter" || this.context.kind === "constructor" || isVoid(this.context.returnType),
+            describeUnitKind(this.context.kind)
+          );
+          const instructions = this.resolveStatements(statements, scope);
           if ((this.context.kind === "function" || this.context.kind === "getter" || this.context.kind === "condition" || this.context.kind === "initializer") && !isVoid(this.context.returnType) && !instructionsTerminate(instructions)) {
             throw new CompileError(
               `Not every reachable ${FALLTHROUGH_LABELS[this.context.kind]} path returns a value or throws.`,
@@ -9790,6 +9970,24 @@ var init_strict_resolver = __esm({
           this.expectedReturnStack.pop();
         }
       }
+      /**
+       * The statements to compile for a unit or lambda, re-deriving an
+       * expression-bodied `=> expr` now that the target's void-ness is known.
+       *
+       * The parser cannot make this call: `=> DoThing()` is a returned value in a
+       * `string` getter and a discarded statement in an action.
+       */
+      expressionBodyOrBlock(node, voidContext, unitLabel2) {
+        const authored = node.expressionBody;
+        if (!authored) return node.body;
+        if (authored.assignment && !voidContext) {
+          throw new CompileError(
+            `An expression-bodied ${unitLabel2} has to produce a value, and an assignment does not; use a block body instead.`,
+            authored.start
+          );
+        }
+        return expressionBodyStatements(authored, voidContext);
+      }
       defineValueAliases(scope) {
         const aliases = this.context.valueAliases ?? [];
         if (aliases.length === 0) return;
@@ -10424,7 +10622,7 @@ var init_strict_resolver = __esm({
               };
             }
             throw new CompileError(
-              "Bare expression statements aren't supported \u2014 every expression must contribute to a return / throw / variable initialiser.",
+              statement.expressionBody ? "A void expression body has to call something; an expression whose value is discarded must move into a block body." : "Bare expression statements aren't supported \u2014 every expression must contribute to a return / throw / variable initialiser.",
               statement.pos
             );
           }
@@ -11427,8 +11625,11 @@ var init_strict_resolver = __esm({
         this.lambdaDepth++;
         this.expectedReturnStack.push(expected.returnType);
         try {
-          const instructions = this.resolveStatements(ast.body, scope);
           const returnsVoid = isVoid(expected.returnType);
+          const instructions = this.resolveStatements(
+            this.expressionBodyOrBlock(ast, returnsVoid, "delegate"),
+            scope
+          );
           if (!returnsVoid && !instructionsTerminate(instructions)) {
             throw new CompileError(
               "Not every reachable delegate path returns a value or throws.",
@@ -11486,6 +11687,13 @@ var init_strict_resolver = __esm({
           (token) => token.pos.line === ast.pos.line && token.pos.column === ast.pos.column
         );
         if (startIndex < 0) return void 0;
+        const expressionBody = ast.expressionBody;
+        if (expressionBody) {
+          const start = sourceOffset(this.source, ast.pos);
+          const end = sourceOffset(this.source, expressionBody.end);
+          if (end <= start) return void 0;
+          return this.source.slice(start, end).trimEnd();
+        }
         const openIndex = tokens.findIndex(
           (token, index) => index > startIndex && token.kind === "punct" && token.text === "{"
         );
@@ -14497,7 +14705,10 @@ var init_strict_resolver = __esm({
         this.lambdaDepth++;
         this.expectedReturnStack.push(returnType);
         try {
-          const instructions = this.resolveStatements(ast.body, scope);
+          const instructions = this.resolveStatements(
+            this.expressionBodyOrBlock(ast, false, "lambda"),
+            scope
+          );
           if (!instructionsTerminate(instructions)) {
             throw new CompileError(
               "Not every reachable lambda path returns a value or throws.",
@@ -15490,14 +15701,15 @@ function compileNeoScriptStrict(document, context, options = {}) {
       (unit) => unit.kind === "function" || unit.kind === "body"
     );
     const expressionDocument = context.kind === "initializerExpression";
-    const compilableSource = expressionDocument ? `return
+    const expressionBodyUnit2 = options.bodyMode === "expression";
+    const compilableSource = expressionBodyUnit2 ? document.text : expressionDocument ? `return
 ${document.text};` : functionUnit ? isolateUnitBody(
       document.text,
       functionUnit.bodyStart,
       functionUnit.bodyEnd
     ) : document.text;
     const resolverContext = expressionDocument ? { ...context, kind: "initializer" } : context;
-    const ast = parseFunctionBody(compilableSource);
+    const ast = expressionBodyUnit2 ? parseExpressionBody(compilableSource) : parseFunctionBody(compilableSource);
     const projectIndex = options.projectIndex ?? createProjectIndex(resolverContext.project);
     const emitted = new StrictNeoScriptResolver(
       resolverContext,
@@ -15556,7 +15768,7 @@ function compileProperty(document, context, units, projectIndex) {
   const getterUnit = units.find((unit) => unit.kind === "getter");
   if (!getterUnit) {
     throw new CompileError(
-      "A NeoScript property sidecar must declare one `get { ... }` unit.",
+      "A NeoScript property sidecar must declare one `get { ... }` or `get => ...;` unit.",
       { line: 1, column: 1 },
       "getter"
     );
@@ -15584,7 +15796,7 @@ function compileProperty(document, context, units, projectIndex) {
 function compileUnit(source, unit, context, label, projectIndex) {
   const isolated = isolateUnitBody(source, unit.bodyStart, unit.bodyEnd);
   try {
-    const ast = parseFunctionBody(isolated);
+    const ast = unit.expressionBody ? parseExpressionBody(isolated) : parseFunctionBody(isolated);
     const indexedProject = projectIndex ?? createProjectIndex(context.project);
     return attachDependencyManifest(
       new StrictNeoScriptResolver(context, indexedProject, isolated).compile(
@@ -17950,8 +18162,8 @@ var init_project_source_parser = __esm({
             docsText
           );
         }
-        if (this.at("{")) {
-          const body = this.captureBody();
+        if (this.at("{") || this.at("=>")) {
+          const body = this.at("{") ? this.captureBody() : this.captureExpressionBody("property");
           this.reportNestedTypes(body);
           const property2 = {
             kind: "property",
@@ -18002,7 +18214,7 @@ var init_project_source_parser = __esm({
         if (this.eat(";")) {
           body = void 0;
         } else {
-          body = this.captureBody();
+          body = this.at("=>") ? this.captureExpressionBody("method") : this.captureBody();
           this.reportNestedTypes(body);
         }
         return {
@@ -18340,6 +18552,36 @@ var init_project_source_parser = __esm({
           range: rangeFrom(open, close)
         };
       }
+      /**
+       * P72 §2. `=> expr;` in member position, reached only when the arrow follows
+       * the member name or the parameter list's `)`. An arrow that follows an `=`
+       * initializer never gets here, so a NeoFlow destination keeps its meaning.
+       */
+      captureExpressionBody(label) {
+        const arrow = this.expect("=>");
+        const expression = this.captureUntilTopLevel(/* @__PURE__ */ new Set([";"]), true);
+        if (expression.text.trim().length === 0) {
+          throw this.failure(
+            "empty-expression-body",
+            `An expression-bodied ${label} needs an expression after \`=>\`.`,
+            this.peek()
+          );
+        }
+        const close = this.previous();
+        if (!this.at(";")) {
+          throw this.failure(
+            "unterminated-expression-body",
+            `An expression-bodied ${label} must end with \`;\`.`,
+            this.peek()
+          );
+        }
+        this.next();
+        return {
+          text: this.source.text.slice(arrow.start, close.end),
+          range: rangeFrom(arrow, close),
+          expression
+        };
+      }
       captureUntilTopLevel(terminators, allowImplicitBodyEnd) {
         const start = this.peek();
         const startCursor = this.cursor;
@@ -24771,6 +25013,10 @@ function findProjectSourceAccessorBody(source, keyword, containingRange) {
   const body = source.slice(bodyStart, bodyEnd);
   const local = new SourceText(body);
   const tokens = lex2(body);
+  if (tokens[0]?.text === "=>") {
+    if (keyword !== "get") return null;
+    return expressionAccessor(source, full, local, tokens, bodyStart, 1);
+  }
   let depth = 0;
   for (let index = 0; index < tokens.length; index++) {
     const token = tokens[index];
@@ -24797,6 +25043,16 @@ function findProjectSourceAccessorBody(source, keyword, containingRange) {
       if (parameterDepth !== 0) return null;
     }
     const open = tokens[openIndex];
+    if (open?.text === "=>") {
+      return expressionAccessor(
+        source,
+        full,
+        local,
+        tokens,
+        bodyStart,
+        openIndex + 1
+      );
+    }
     if (open?.text !== "{") return null;
     let accessorDepth = 1;
     for (let cursor = openIndex + 1; cursor < tokens.length; cursor++) {
@@ -24808,13 +25064,52 @@ function findProjectSourceAccessorBody(source, keyword, containingRange) {
       const end = bodyStart + sourceOffset2(local, candidate.pos);
       return {
         range: full.range(start, end),
-        source: source.slice(start, end)
+        source: source.slice(start, end),
+        form: "block"
       };
     }
     return null;
   }
   return null;
 }
+function expressionAccessor(source, full, local, tokens, bodyStart, firstIndex) {
+  const first = tokens[firstIndex];
+  if (!first) return null;
+  const start = bodyStart + sourceOffset2(local, first.pos);
+  let end = bodyStart + local.text.length;
+  let depth = 0;
+  for (let cursor = firstIndex; cursor < tokens.length; cursor++) {
+    const token = tokens[cursor];
+    if (token.kind !== "punct") continue;
+    if (token.text === "{" || token.text === "(" || token.text === "[") {
+      depth++;
+      continue;
+    }
+    if (token.text === ")" || token.text === "]") {
+      depth--;
+      continue;
+    }
+    if (token.text === "}") {
+      if (depth === 0) {
+        end = bodyStart + sourceOffset2(local, token.pos);
+        break;
+      }
+      depth--;
+      continue;
+    }
+    if (depth === 0 && token.text === ";") {
+      end = bodyStart + sourceOffset2(local, token.pos);
+      break;
+    }
+  }
+  const trimmed = source.slice(start, end).trimEnd();
+  if (trimmed.length === 0) return null;
+  return {
+    range: full.range(start, start + trimmed.length),
+    source: trimmed,
+    form: "expression"
+  };
+}
 function sourceOffset2(source, position) {
   return source.offsetAt({
     line: Math.max(0, position.line - 1),
@@ -24939,6 +25234,7 @@ function compileProjectSourceBodies(documents) {
           staticMember
         };
         if (member.kind === "function" && member.body) {
+          const expressionBody = member.body.expression;
           compileBody({
             uri,
             document,
@@ -24947,7 +25243,8 @@ function compileProjectSourceBodies(documents) {
             declarationRange: member.nameRange,
             memberId: info.symbol.id,
             unit: "function",
-            range: innerBodyRange(document.sourceText, member.body.range),
+            range: expressionBody?.range ?? innerBodyRange(document.sourceText, member.body.range),
+            ...expressionBody ? { bodyMode: "expression" } : {},
             context: {
               ...baseContext2,
               kind: "function",
@@ -24970,12 +25267,12 @@ function compileProjectSourceBodies(documents) {
         }
         if (member.kind !== "property") continue;
         for (const unit of ["getter", "setter"]) {
-          const range2 = findProjectSourceAccessorBody(
+          const accessor = findProjectSourceAccessorBody(
             document.sourceText,
             unit === "getter" ? "get" : "set",
             member.body.range
-          )?.range;
-          if (!range2) continue;
+          );
+          if (!accessor) continue;
           compileBody({
             uri,
             document,
@@ -24984,7 +25281,8 @@ function compileProjectSourceBodies(documents) {
             declarationRange: member.nameRange,
             memberId: info.symbol.id,
             unit,
-            range: range2,
+            range: accessor.range,
+            ...accessor.form === "expression" ? { bodyMode: "expression" } : {},
             context: { ...baseContext2, kind: unit },
             projectIndex,
             bodies,
@@ -25017,7 +25315,10 @@ function compileBody(args) {
       text: maskOutside(args.document.sourceText, start, end)
     },
     args.context,
-    { projectIndex: args.projectIndex }
+    {
+      projectIndex: args.projectIndex,
+      ...args.bodyMode ? { bodyMode: args.bodyMode } : {}
+    }
   );
   for (const diagnostic of result.diagnostics) {
     args.diagnostics.push({
@@ -26614,7 +26915,7 @@ function validateClassMemberModifiers(ref, environment, diagnostics) {
         `Abstract member '${member.name}' cannot declare a default initializer.`
       );
     }
-    if (modifiers.has("abstract") && member.kind === "property" && /\b(?:get|set)\s*\{/.test(member.body.text)) {
+    if (modifiers.has("abstract") && member.kind === "property" && (member.body.expression !== void 0 || /\b(?:get|set)\s*\{/.test(member.body.text))) {
       diagnose(
         diagnostics,
         ref.uri,
@@ -27017,6 +27318,7 @@ function valueAccessors(member, environment) {
     };
   }
   if (member.kind === "function") return { get: false, set: false };
+  if (member.body.expression) return { get: true, set: false };
   return {
     get: /\bget\b/.test(member.body.text),
     set: /\bset\b/.test(member.body.text)
@@ -33296,9 +33598,10 @@ function scriptDefinitionLocations(member, environment, field) {
   const firstNonWhitespace = sourceText.search(/\S/);
   const startOffset = headerMember?.[1] === void 0 ? Math.max(firstNonWhitespace, 0) : sourceText.indexOf(headerMember[1]);
   const start = positionAt(sourceText, startOffset);
-  const tokenLength = headerMember?.[1] !== void 0 ? headerMember[1].length : kind === "property" && sourceText.slice(startOffset).startsWith("get") ? 3 : Math.max(
-    /^[A-Za-z_][A-Za-z0-9_]*/.exec(sourceText.slice(startOffset))?.[0].length ?? 1,
-    1
+  const tokenLength = definitionTokenLength(
+    sourceText.slice(startOffset),
+    kind,
+    headerMember?.[1]
   );
   return {
     definitionLocations: [
@@ -33312,6 +33615,12 @@ function scriptDefinitionLocations(member, environment, field) {
     ]
   };
 }
+function definitionTokenLength(tail, kind, headerName) {
+  if (headerName !== void 0) return headerName.length;
+  if (kind === "property" && tail.startsWith("get")) return 3;
+  if (tail.startsWith("=>")) return 2;
+  return Math.max(/^[A-Za-z_][A-Za-z0-9_]*/.exec(tail)?.[0].length ?? 1, 1);
+}
 function positionAt(text, offset) {
   let line = 0;
   let character = 0;
@@ -50964,6 +51273,7 @@ function emitProjectSourcesV4(manifest, options = {}) {
     fileSymbols: options.fileSymbols ?? /* @__PURE__ */ new Map(),
     collectionValuePaths: options.collectionValuePaths ?? /* @__PURE__ */ new Map(),
     variantPathsById: buildVariantPathsByIdV4(manifest),
+    formAlternates: [],
     templateNames: new Map(
       [...manifest.textureTemplates, ...manifest.audioTemplates].map(
         (template) => [template.id, template.name]
@@ -50971,6 +51281,7 @@ function emitProjectSourcesV4(manifest, options = {}) {
     )
   };
   const files = [];
+  const formAlternates = [];
   const localizationStatusNames = new Map(
     manifest.localizationStatuses.map((entry) => [
       entry.id,
@@ -50982,9 +51293,14 @@ function emitProjectSourcesV4(manifest, options = {}) {
     const relationIds = manifest.internalRecordRelations.filter(
       (relation) => relation.sourceRecordKind === "class" && relation.sourceRecordId === schemaClass2.id && specializedRelationProperty(relation.relationKind) !== null
     ).map((relation) => relation.id);
+    const path = `Classes/${schemaClass2.name}.neo`;
+    const content = emitClass(context, schemaClass2, ownMemberIds);
+    formAlternates.push(
+      ...context.formAlternates.splice(0).map((draft) => ({ path, ...draft }))
+    );
     files.push({
-      path: `Classes/${schemaClass2.name}.neo`,
-      content: emitClass(context, schemaClass2, ownMemberIds),
+      path,
+      content,
       recordKeys: [
         `class:${schemaClass2.id}`,
         ...(schemaClass2.constructorIds ?? []).map((id2) => `constructor:${id2}`),
@@ -51067,7 +51383,7 @@ function emitProjectSourcesV4(manifest, options = {}) {
   for (const file of files) {
     for (const key of file.recordKeys) recordFiles.set(key, file.path);
   }
-  return { files, recordFiles };
+  return { files, recordFiles, formAlternates };
 }
 function emitGenericRelations(context, relations, endpointExpressions) {
   const ordered = [...relations].sort(
@@ -51197,10 +51513,16 @@ ${schemaClass2.genericParameters.map((parameter4) => {
   const header = `${modifier}class ${schemaClass2.name}${generics}${headerParameters}${bases.length ? ` : ${bases.join(", ")}` : ""} {`;
   const rendered = memberIds.map((memberId) => {
     const member = required(context.members, memberId, "member");
-    return {
-      member,
-      source: indentNeoSourceNonEmptyLines(emitMember(context, member, schemaClass2.id), 2)
-    };
+    const alternateIndex = context.formAlternates.length;
+    const source = indentNeoSourceNonEmptyLines(emitMember(context, member, schemaClass2.id), 2);
+    for (let at = alternateIndex; at < context.formAlternates.length; at++) {
+      const alternate = context.formAlternates[at];
+      context.formAlternates[at] = {
+        shorthand: indentNeoSourceNonEmptyLines(alternate.shorthand, 2),
+        block: indentNeoSourceNonEmptyLines(alternate.block, 2)
+      };
+    }
+    return { member, source };
   });
   const constructorIds = schemaClass2.constructorIds ?? [];
   const sources = rendered.map((entry) => entry.source);
@@ -51431,25 +51753,44 @@ function emitMember(context, member, enclosingClassId) {
   if (member.kind === "computed") {
     const getter = member.script?.getterSource?.trim();
     const setter = member.script?.setterSource?.trim();
-    const body = getter ? ` {
-  get {
-${indentNeoSourceNonEmptyLines(getter, 4)}
-  }${setter ? `
+    const head = `${annotations.join("\n")}
+${prefix}${renderType(context, member.returnType)} ${member.name}`;
+    if (!getter) return `${head} { get; }`;
+    const setterBlock = setter ? `
 
   set {
 ${indentNeoSourceNonEmptyLines(setter, 4)}
-  }` : ""}
-}` : " { get; }";
-    return `${annotations.join("\n")}
-${prefix}${renderType(context, member.returnType)} ${member.name}${body}`;
+  }` : "";
+    const block = `${head} {
+  get {
+${indentNeoSourceNonEmptyLines(getter, 4)}
+  }${setterBlock}
+}`;
+    const expression = expressionBodyExpression(getter);
+    if (expression === null) return block;
+    const shorthand = setter ? `${head} {
+  get => ${expression};${setterBlock}
+}` : `${head} => ${expression};`;
+    context.formAlternates.push({ shorthand, block });
+    return shorthand;
   }
   if (member.kind === "function" || member.kind === "scriptFunction") {
     const signature = `${prefix}${member.deferred ? "async " : ""}${renderReturnType(context, member.returnType)} ${member.name}(${member.arguments.map((argument2) => renderParameter(context, argument2)).join(", ")})`;
     const tracked = member.kind === "scriptFunction" ? member.script?.sourceText ?? uiFunctionSource(context, member) : null;
     const body = tracked === null ? null : emitFunctionBody(tracked);
     const abstractContract = member.modifier === "abstract" || member.modifier === "abstractOverride";
-    return `${annotations.join("\n")}
-${body !== null ? `${signature} ${body}` : abstractContract ? `${signature};` : `native ${signature};`}`;
+    if (body === null) {
+      return `${annotations.join("\n")}
+${abstractContract ? `${signature};` : `native ${signature};`}`;
+    }
+    const block = `${annotations.join("\n")}
+${signature} ${body}`;
+    const expression = expressionBodyExpression(tracked ?? "");
+    if (expression === null) return block;
+    const shorthand = `${annotations.join("\n")}
+${signature} => ${expression};`;
+    context.formAlternates.push({ shorthand, block });
+    return shorthand;
   }
   const type = renderMemberType(context, member, enclosingClassId);
   const initializer = initDefaultSource(member) ?? (member.isStatic ? context.staticInitializers.get(member.id) : void 0) ?? context.defaultInitializers.get(member.id) ?? renderDefault(context, member);
@@ -52320,6 +52661,22 @@ function systemAnnotation2(system) {
   ];
   return `@system(${args.join(", ")})`;
 }
+function expressionBodyExpression(sourceText) {
+  const trimmed = sourceText.trim();
+  if (trimmed.includes("\n")) return null;
+  if (!trimmed.startsWith("return") || !trimmed.endsWith(";")) return null;
+  let parsed;
+  try {
+    parsed = parseFunctionBody(trimmed);
+  } catch {
+    return null;
+  }
+  const statement = parsed.body[0];
+  if (parsed.body.length !== 1 || statement?.kind !== "return") return null;
+  if (statement.expr === null) return null;
+  const expression = trimmed.slice("return".length, -1).trim();
+  return expression.length === 0 ? null : expression;
+}
 function emitFunctionBody(sourceText) {
   const code = sourceText.trim();
   if (code.length === 0) return "{\n}";
@@ -53772,7 +54129,7 @@ function parseDialogueGroupFunctions(source) {
     return {
       id: annotationId(member.annotations),
       name: member.name,
-      code: member.body === void 0 ? null : innerSourceBody(member.body.text)
+      code: member.body === void 0 ? null : dialogueGroupCode(member.body)
     };
   });
 }
@@ -53825,8 +54182,9 @@ function annotationId(annotations) {
   }
   return parsed;
 }
-function innerSourceBody(body) {
-  const trimmed = body.trim();
+function dialogueGroupCode(body) {
+  if (body.expression) return `return ${body.expression.text.trim()};`;
+  const trimmed = body.text.trim();
   return trimmed.slice(1, -1).trim();
 }
 function resolveOptionalReference(expression, symbols) {
@@ -57817,7 +58175,7 @@ function lowerMemberKind(context, ownerClass, declaration, id2, owner) {
     }
     if (declaration.body !== null) {
       const sourceText = preserveEquivalentCode(
-        innerBody2(declaration.body),
+        functionBodySource(declaration.body, returnType.kind === "void"),
         base?.kind === "scriptFunction" ? base.script?.sourceText : null
       );
       const uiAction = logicMode === "UI" ? lowerUiFunctionAction(
@@ -59119,7 +59477,7 @@ function lowerExpressionValue(context, expression, declaredExpected, ownerClass,
           `A lambda at ${path} requires a NeoDelegate expected type.`
         );
       }
-      const code = sourceText === void 0 ? null : lambdaExpressionSource(sourceText, expression.pos);
+      const code = sourceText === void 0 ? null : lambdaExpressionSource(sourceText, expression);
       if (code === null || code.length === 0) {
         throw new Error(`Delegate value ${path} has no recoverable source.`);
       }
@@ -59232,14 +59590,25 @@ function isStoredActionLiteral(type, expression) {
   while (current.kind === "annotated") current = current.expression;
   return current.kind === "litList";
 }
-function lambdaExpressionSource(source, pos) {
-  let start = 0;
+function sourceOffsetAt(source, pos) {
+  let offset = 0;
   for (let line = 1; line < pos.line; line += 1) {
-    const next = source.indexOf("\n", start);
+    const next = source.indexOf("\n", offset);
     if (next < 0) return null;
-    start = next + 1;
+    offset = next + 1;
+  }
+  return Math.min(offset + pos.column - 1, source.length);
+}
+function lambdaExpressionSource(source, lambda) {
+  const start = sourceOffsetAt(source, lambda.pos);
+  if (start === null) return null;
+  const expressionBody = lambda.expressionBody;
+  if (expressionBody) {
+    const end = sourceOffsetAt(source, expressionBody.end);
+    if (end === null || end <= start) return null;
+    const slice = source.slice(start, end).trimEnd();
+    return slice.length === 0 ? null : slice;
   }
-  start = Math.min(start + pos.column - 1, source.length);
   const arrow = source.indexOf("=>", start);
   if (arrow < 0) return null;
   const bodyStart = source.indexOf("{", arrow + 2);
@@ -59837,14 +60206,22 @@ function memberModifier3(modifiers, baseModifier) {
 function propertyAccessors(body) {
   const accessorBody = (keyword) => {
     const accessor = findProjectSourceAccessorBody(body, keyword);
-    return accessor === null ? null : normalizeBodySource(accessor.source);
+    if (accessor === null) return null;
+    const source = normalizeBodySource(accessor.source);
+    if (accessor.form === "block") return source;
+    return keyword === "get" ? `return ${source};` : `${source};`;
   };
   return {
     get: accessorBody("get"),
     set: accessorBody("set")
   };
 }
-function innerBody2(body) {
+function functionBodySource(body, isVoid2) {
+  const trimmed = body.trim();
+  if (trimmed.startsWith("=>")) {
+    const expression = normalizeBodySource(trimmed.slice(2));
+    return isVoid2 ? `${expression};` : `return ${expression};`;
+  }
   const start = body.indexOf("{");
   const end = body.lastIndexOf("}");
   if (start < 0 || end <= start) return normalizeBodySource(body);
@@ -103466,7 +103843,13 @@ ${errors.map(
       ).join("\n")}`
     );
   }
-  return { files, recordFiles, analysis, materializedConstructors };
+  return {
+    files,
+    recordFiles,
+    analysis,
+    materializedConstructors,
+    formAlternates: source.formAlternates
+  };
 }
 function relationEndpointExpressions(records2) {
   const ownerByMemberId = /* @__PURE__ */ new Map();
@@ -112325,6 +112708,30 @@ function applyPushResult(workspace, result, pendingIdAssignments = /* @__PURE__
   rewriteFilesFromState(workspace, void 0, preservedSourceFiles);
   writeWorkspaceState(workspace.root, workspace.state);
 }
+function authoredMemberFormsByFile(root, alternates) {
+  const authored = /* @__PURE__ */ new Map();
+  const contents = /* @__PURE__ */ new Map();
+  for (const alternate of alternates) {
+    let existing = contents.get(alternate.path);
+    if (existing === void 0) {
+      const absolute = join15(root, alternate.path);
+      existing = existsSync11(absolute) ? readFileSync15(absolute, "utf8") : null;
+      contents.set(alternate.path, existing);
+    }
+    if (existing === null || !existing.includes(alternate.block)) continue;
+    const bucket = authored.get(alternate.path);
+    if (bucket) bucket.push(alternate);
+    else authored.set(alternate.path, [alternate]);
+  }
+  return authored;
+}
+function restoreAuthoredMemberForms(content, alternates) {
+  let result = content;
+  for (const alternate of alternates) {
+    result = result.split(alternate.shorthand).join(alternate.block);
+  }
+  return result;
+}
 function rewriteFilesFromState(workspace, records2 = new Map(
   Object.entries(workspace.state.records).map(([key, recordState]) => [
     key,
@@ -112338,9 +112745,16 @@ function rewriteFilesFromState(workspace, records2 = new Map(
   ])
 ), preservedSourceFiles = /* @__PURE__ */ new Map()) {
   const result = emitProjectDocumentFilesV4(records2);
+  const authoredForms = authoredMemberFormsByFile(
+    workspace.root,
+    result.formAlternates
+  );
   const files = result.files.map((file) => ({
     ...file,
-    content: preservedSourceFiles.get(file.path) ?? file.content
+    content: preservedSourceFiles.get(file.path) ?? restoreAuthoredMemberForms(
+      file.content,
+      authoredForms.get(file.path) ?? []
+    )
   }));
   const finalAnalysis = compileNeoProjectSources(
     files.map((file) => {
@@ -112487,7 +112901,7 @@ function materializeAssignedSchemaIdsInAuthoredSource(workspace, replacements, p
     if (source === void 0) continue;
     const edits = editsByUri.get(uri) ?? [];
     if (entry.identity.id === null) {
-      const start = sourceOffsetAt(
+      const start = sourceOffsetAt2(
         source,
         entry.identity.source.range.start.line,
         entry.identity.source.range.start.character
@@ -112519,7 +112933,7 @@ function materializeAssignedSchemaIdsInAuthoredSource(workspace, replacements, p
     if (assignedId === void 0) continue;
     const source = inputByUri.get(site.uri);
     if (source === void 0) continue;
-    const declarationOffset = sourceOffsetAt(
+    const declarationOffset = sourceOffsetAt2(
       source,
       site.declarationStart.line,
       site.declarationStart.character
@@ -112587,7 +113001,7 @@ function pendingIdentityUri(pendingId2) {
     return null;
   }
 }
-function sourceOffsetAt(source, line, character) {
+function sourceOffsetAt2(source, line, character) {
   let offset = 0;
   for (let currentLine = 0; currentLine < line; currentLine += 1) {
     const newline = source.indexOf("\n", offset);
@@ -113181,7 +113595,7 @@ var init_registry2 = __esm({
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
       formatVersion: 3,
       contractVersion: "3.14",
-      cliVersion: "0.34.2",
+      cliVersion: "0.35.0",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -119783,7 +120197,7 @@ There is no --keep-current: preserving current semantic state defines flatten.
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   if (args.command === "--version") {
-    console.log("0.34.2");
+    console.log("0.35.0");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neocompose/cli",
-  "version": "0.34.2",
+  "version": "0.35.0",
   "description": "Neo Compose native project-source CLI with bidirectional sync.",
   "license": "MIT",
   "type": "module",

package/skills/neocompose-cli/SKILL.md

@@ -9,7 +9,7 @@ description: >-
   `@neocompose/cli` or `node cli/bin/neo.mjs` in the neo-compose repository.
 ---
 
-<!-- reviewed-through-cli: 0.34.2 -->
+<!-- reviewed-through-cli: 0.35.0 -->
 
 # Neo Compose CLI
 
@@ -47,9 +47,8 @@ Treat pull followed immediately by status or dry-run as a semantic no-op. If it
 reports project changes, stop and report a round-trip bug instead of pushing.
 
 The compiler reports file:line:column diagnostics and fails closed. Unknown
-non-null authorable server fields require a CLI contract update; never preserve
-them as opaque JSON or guessed syntax. An unknown top-level document field whose
-value is exactly JSON `null` is treated as absent.
+authorable server fields require a CLI contract update; never preserve them as
+opaque JSON or guessed syntax.
 
 ## Honor hard authoring invariants
 

package/skills/neocompose-cli/references/animation-and-world-authoring.md

@@ -45,9 +45,12 @@ NeoVariant<ExampleObject> Down = new(
   required: it is the only way to construct through the variant.
 - `apply` takes exactly one parameter of the target class and is void. Omit it
   for a variant that is only ever constructed.
-- Both are ordinary delegate closures: parenthesized parameter list, block
-  body, no expression-bodied form. The server compiles them, so authored source
-  carries only the code.
+- Both are ordinary delegate closures: parenthesized parameter list, then
+  either a block body or an expression body. `initialize` returns, so
+  `() => new ExampleObject(.Down)` works; `apply` is void, so its expression
+  body must be a call or an assignment, as in
+  `(source) => source.FacingDir = .Down`. The server compiles them, so authored
+  source carries only the code.
 
 Folders are records too, declared as their own globals and assigned per
 variant. Nesting is spelled in the path with `/`; intermediate segments are
@@ -346,8 +349,11 @@ node bindings scoped to their node/children. Give each persisted condition use,
 action invocation, mutation, pause, option, and node its own owner-scoped ID.
 
 Use `=> Next` or a trailing block with `return Next;`; do not author a `to:`
-argument. Require destinations for triggers, options, and outcomes. Permit
-terminal text/actions to fall through. Keep all statements for
+argument. A destination arrow always follows an `=` initializer, as in
+`= new(...) => Welcome;`; an arrow that instead follows a member name or a
+parameter list's `)` is a NeoScript expression body, so the two never collide.
+Require destinations for triggers, options, and outcomes. Permit terminal
+text/actions to fall through. Keep all statements for
 `Actions Empty = new();` inside its body.
 
 After editing, run `neo dialogue dryrun <dialogue-ref>`. Exit 1 means the graph

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

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

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

@@ -25,6 +25,41 @@ Declare a setter's value type explicitly with the canonical form
 `set(int value) { ... }`. Project analysis, candidate materialization, and
 focused script commands all use the same accessor extraction.
 
+A body whose whole point is one expression may be written as an expression
+body, `=> expr;`. It is pure sugar for the block form — same compiled
+instructions, same diagnostics, same stored source — and is available on
+getter-only properties, individual accessors, and functions:
+
+```neo
+public bool HasVisited => this.VisitCount > 0;
+
+public int Clamped {
+  get => Math.Clamp(this.Raw, 0, 10);
+  set(int value) { this.Raw = value; }
+}
+
+public bool Unlocked(int level) => this.Level >= level;
+```
+
+The `=>` is only an expression body where it directly follows the member name
+or the parameter list's `)`. An arrow after an `=` initializer is always a
+NeoFlow destination, so `override Trigger Trigger = new(...) => Welcome;`
+keeps its meaning.
+
+In a void context — a `void` function, a setter, or a void delegate — `=> expr`
+is an expression statement rather than a return, so the expression must do
+something: a call such as `void Ping() => this.OnChanged();`, or an assignment
+such as `set(int value) => this.Raw = value;`. An expression whose value would
+simply be discarded is rejected with a diagnostic that names the block body as
+the fix.
+
+`neo push` and `neo pull` canonicalize a stored body to the shorthand when its
+authored spelling is exactly one `return` statement that fits on one line;
+anything else re-emits as a block. Setters always re-emit as blocks. A push
+preserves the form you authored for members it did not otherwise rewrite, so
+choosing longhand for a one-line getter is stable; a fresh `neo pull` writes
+the canonical shorthand.
+
 Declare a bodyless NeoScript contract with `abstract`, for example
 `public abstract bool Equals(Item other);`. Reserve `native` for host-provided
 functions; concrete NeoScript overrides inherit the abstract signature.
@@ -55,6 +90,15 @@ so later changes to the outer binding do not alter the closure. Explicit lambda
 parameter annotations accept the same type grammar as declarations, including
 `decimal`, generic parameters, collections, arrays, and nullable types.
 
+A lambda may use an expression body too: `(x) => x * 2` is the block body
+`(x) => { return x * 2; }`. In a void delegate the expression is a statement,
+so it must call or assign. A dictionary-literal body needs parentheses,
+`() => ({ "a": 1 })`, because a bare `{` after the arrow always opens a block.
+
+```neo
+List<Item> ready = this.Items.Where((item) => item.Count > 0);
+```
+
 Calling `Equals(other)` on a non-null generic value dynamically uses the
 runtime Class's one-argument `Equals` Function or NSFunction when it returns
 `bool`, including the effective override. Values without that member fall back

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

@@ -39,9 +39,7 @@ class Assets {
   };
 
   @id("home-getter-id")
-  static Outpost Home {
-    get { return Assets.Capitol; }
-  }
+  static Outpost Home => Assets.Capitol;
 }
 ```