@neocompose/cli 0.32.4 → 0.33.0

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 # Changelog
 
+## [0.33.0] - 2026-08-19
+
+### Added
+
+- Add lazy, right-associative conditional expressions with the familiar
+  `condition ? whenTrue : whenFalse` spelling. Both result arms are
+  target-typed and only the selected arm runs in CLI tests, web previews, and
+  the Unity runtime. Project exports now use schema version 24 and compiled
+  NeoScript bodies use compiler revision 12 so older runtimes fail at their
+  normal compatibility gate.
+- Add `NeoAction.Clear()` as the statement-form way to replace an action's
+  stored listener set with the empty set.
+- Allow returned inline `NeoDelegate` lambdas to capture surrounding locals
+  and parameters by value. Captures are explicit in revision-12 IR and remain
+  available after the delegate is stored or serialized.
+- Accept every NeoScript type grammar in explicit lambda parameters, including
+  `decimal`, generic parameters, collections, arrays, and nullable types.
+
+### Fixed
+
+- Resolve local type annotations such as `T modifiedValue` against the
+  declaring Class's generic parameters instead of synthesizing an unrelated
+  type named `T`.
+- Support `Equals(...)` on a non-null generic type parameter. Runtime Class
+  values dispatch a compatible one-argument, bool-returning `Equals` Function
+  or NSFunction (including overrides); other values use ordinary NeoScript
+  equality.
+- Parse `value is Type ? whenTrue : whenFalse` as a conditional expression
+  instead of consuming its question mark as a forbidden nullable `is Type?`
+  suffix.
+- Use the strict compiler's numeric/nullability join rules when validating
+  project-source conditional branches, and make nested-lambda shadowing
+  diagnostics independent of whether an outer value was captured earlier.
+
 ## [0.32.4] - 2026-08-18
 
 ### Fixed

package/dist/neo.mjs

@@ -6467,12 +6467,26 @@ function makeBinary(op, left, right, pos) {
   return { kind: "binary", op, left, right, pos };
 }
 function asASTBinaryOp(text) {
-  if (!AST_BINARY_OPS.has(text)) {
-    throw new Error(
-      `Internal compiler error: '${text}' is not a valid ASTBinaryOp`
-    );
+  switch (text) {
+    case "+":
+    case "-":
+    case "*":
+    case "/":
+    case "%":
+    case "==":
+    case "!=":
+    case "<":
+    case ">":
+    case "<=":
+    case ">=":
+    case "&&":
+    case "||":
+      return text;
+    default:
+      throw new Error(
+        `Internal compiler error: '${text}' is not a valid ASTBinaryOp`
+      );
   }
-  return text;
 }
 function isAssignmentOp(token) {
   return token.kind === "op" && (token.text === "=" || token.text === "+=" || token.text === "-=" || token.text === "*=" || token.text === "/=" || token.text === "%=");
@@ -6488,7 +6502,7 @@ function describeToken(t) {
   if (t.kind === "eof") return "end of input";
   return `'${t.text}'`;
 }
-var Parser, AST_BINARY_OPS;
+var Parser;
 var init_strict_parser = __esm({
   "../packages/neoscript-language/src/strict-parser.ts"() {
     "use strict";
@@ -6979,7 +6993,7 @@ var init_strict_parser = __esm({
       // Types
       // ------------------------------------------------------------------
       /** Parses a type annotation (used in varDecls and Dictionary generics). */
-      parseType() {
+      parseType(options = {}) {
         const startPos = this.peek().pos;
         let inner;
         const t = this.peek();
@@ -7045,17 +7059,73 @@ var init_strict_parser = __esm({
             pos: arrPos
           };
         }
-        if (this.peek().kind === "op" && this.peek().text === "?") {
+        if (this.peek().kind === "op" && this.peek().text === "?" && !(options.conditionalQuestion === true && this.hasMatchingConditionalColon(this.i))) {
           this.next();
           inner = { ...inner, required: false };
         }
         return inner;
       }
+      /**
+       * `is T ? a : b` is ambiguous at the token level because `?` is also the
+       * nullable type suffix. A colon at the same delimiter depth makes it the
+       * conditional operator; nested ternaries are paired before the outer colon.
+       */
+      hasMatchingConditionalColon(questionIndex) {
+        let delimiterDepth2 = 0;
+        let nestedQuestions = 0;
+        for (let index = questionIndex + 1; index < this.tokens.length; index += 1) {
+          const token = this.tokens[index];
+          if (token === void 0) return false;
+          if (token.kind === "punct") {
+            if (token.text === "(" || token.text === "[" || token.text === "{") {
+              delimiterDepth2 += 1;
+              continue;
+            }
+            if (token.text === ")" || token.text === "]" || token.text === "}") {
+              if (delimiterDepth2 === 0) return false;
+              delimiterDepth2 -= 1;
+              continue;
+            }
+            if (delimiterDepth2 !== 0) continue;
+            if (token.text === ";" || token.text === ",") return false;
+            if (token.text !== ":") continue;
+            if (nestedQuestions === 0) return true;
+            nestedQuestions -= 1;
+            continue;
+          }
+          if (delimiterDepth2 === 0 && token.kind === "op" && token.text === "?") {
+            nestedQuestions += 1;
+          }
+        }
+        return false;
+      }
       // ------------------------------------------------------------------
       // Expressions — climbing precedence (lowest first)
       // ------------------------------------------------------------------
       parseExpr() {
-        return this.parseCoalesce();
+        return this.parseConditional();
+      }
+      /**
+       * Conditional `condition ? whenTrue : whenFalse`. This is the lowest
+       * precedence expression operator and is right-associative, matching the
+       * familiar C#/TypeScript reading of nested ternaries.
+       */
+      parseConditional() {
+        const condition = this.parseCoalesce();
+        if (!(this.peek().kind === "op" && this.peek().text === "?")) {
+          return condition;
+        }
+        const question = this.next();
+        const whenTrue = this.parseExpr();
+        this.expect("punct", ":");
+        const whenFalse = this.parseConditional();
+        return {
+          kind: "conditional",
+          condition,
+          whenTrue,
+          whenFalse,
+          pos: question.pos
+        };
       }
       /**
        * Null-coalesce `lhs ?? rhs`. Lower precedence than `||` / `&&` so
@@ -7103,7 +7173,7 @@ var init_strict_parser = __esm({
           }
           if (t.kind === "keyword" && t.text === "is") {
             this.next();
-            const type = this.parseType();
+            const type = this.parseType({ conditionalQuestion: true });
             const bindingName = this.peek().kind === "ident" ? this.next().text : null;
             left = { kind: "is", operand: left, type, bindingName, pos: t.pos };
             continue;
@@ -7538,13 +7608,8 @@ var init_strict_parser = __esm({
        */
       parseLambdaParam() {
         const startPos = this.peek().pos;
-        const t = this.peek();
-        if (t.kind === "keyword" && (t.text === "int" || t.text === "float" || t.text === "bool" || t.text === "string" || t.text === "Dictionary")) {
-          const type = this.parseType();
-          const name2 = this.expect("ident");
-          return { type, name: name2.text, pos: startPos };
-        }
-        if (t.kind === "ident" && this.tokens[this.i + 1]?.kind === "ident") {
+        const afterType = this.scanType(this.i);
+        if (afterType !== null && this.tokens[afterType]?.kind === "ident") {
           const type = this.parseType();
           const name2 = this.expect("ident");
           return { type, name: name2.text, pos: startPos };
@@ -7607,21 +7672,6 @@ var init_strict_parser = __esm({
         return { kind: "litInterp", parts, pos };
       }
     };
-    AST_BINARY_OPS = /* @__PURE__ */ new Set([
-      "+",
-      "-",
-      "*",
-      "/",
-      "%",
-      "==",
-      "!=",
-      "<",
-      ">",
-      "<=",
-      ">=",
-      "&&",
-      "||"
-    ]);
   }
 });
 
@@ -8225,7 +8275,7 @@ var NEOSCRIPT_COMPILER_REVISION;
 var init_strict_ir = __esm({
   "../packages/neoscript-language/src/strict-ir.ts"() {
     "use strict";
-    NEOSCRIPT_COMPILER_REVISION = 11;
+    NEOSCRIPT_COMPILER_REVISION = 12;
   }
 });
 
@@ -8628,6 +8678,11 @@ function collectAssignedPathRootsInExpression(expression, roots) {
       collectAssignedPathRootsInExpression(expression.left, roots);
       collectAssignedPathRootsInExpression(expression.right, roots);
       return;
+    case "conditional":
+      collectAssignedPathRootsInExpression(expression.condition, roots);
+      collectAssignedPathRootsInExpression(expression.whenTrue, roots);
+      collectAssignedPathRootsInExpression(expression.whenFalse, roots);
+      return;
     case "unary":
     case "force":
       collectAssignedPathRootsInExpression(expression.operand, roots);
@@ -9515,6 +9570,7 @@ var init_strict_resolver = __esm({
         this.context = context;
         this.source = source;
         this.project = projectIndex ?? createProjectIndex(context.project);
+        this.sourceTokens = source === void 0 ? void 0 : lex2(source);
         const unknown = { kind: "primitive", name: "unknown" };
         this.thisVariable = variable(
           "__this__",
@@ -9560,6 +9616,9 @@ var init_strict_resolver = __esm({
       argumentVariables;
       callSiteCounter = 0;
       lambdaDepth = 0;
+      delegateClosureCounter = 0;
+      delegateCaptureContexts = [];
+      sourceTokens;
       unreachableControlEffectDepth = 0;
       catchBindingCounter = 0;
       catchContexts = [];
@@ -10276,6 +10335,12 @@ var init_strict_resolver = __esm({
           case "assign":
             return this.resolveAssignment(statement, scope);
           case "exprStmt": {
+            const actionClear = this.resolveActionClear(
+              statement.expr,
+              scope,
+              statement.pos
+            );
+            if (actionClear) return actionClear;
             const collectionCall = this.resolveCollectionMutation(
               statement.expr,
               scope,
@@ -10420,7 +10485,10 @@ var init_strict_resolver = __esm({
             pos
           );
         }
-        if (!scope.lookup(name)) return;
+        const usedInLexicalOuter = this.delegateCaptureContexts.some(
+          (context) => context.outerScope.lookup(name) !== null
+        );
+        if (!scope.lookup(name) && !usedInLexicalOuter) return;
         throw new CompileError(
           `Cannot declare local '${name}' because that name is already used in an enclosing or current scope.`,
           pos
@@ -10579,7 +10647,9 @@ var init_strict_resolver = __esm({
         }
         const local = statement.target.kind === "ident" ? scope.lookup(statement.target.name) : null;
         if (local?.readonlyBinding) {
-          const label = local.readonlyBinding === "catch" ? "catch parameter" : "foreach iterator";
+          let label = "foreach iterator";
+          if (local.readonlyBinding === "catch") label = "catch parameter";
+          if (local.readonlyBinding === "capture") label = "captured value";
           throw new CompileError(
             `Cannot assign to ${label} '${local.name}' because it is read-only.`,
             statement.pos
@@ -11179,6 +11249,8 @@ var init_strict_resolver = __esm({
               type: resultType
             };
           }
+          case "conditional":
+            return this.resolveConditionalExpression(expression, scope, expected);
           case "is": {
             const operand = this.resolveExpression(expression.operand, scope);
             const check = this.resolveType(expression.type);
@@ -11223,19 +11295,40 @@ var init_strict_resolver = __esm({
             ast.pos
           );
         }
-        const scope = new Scope(outerScope);
+        const serial = this.delegateClosureCounter++;
+        const scope = new Scope(null);
+        scope.define(
+          scopeVariable(
+            "this",
+            this.thisVariable,
+            this.context.thisClass,
+            void 0,
+            "runtime" /* Runtime */
+          )
+        );
+        const rootSymbol = this.context.project.roots.find(
+          (candidate) => candidate.name === "root"
+        );
+        scope.define(scopeVariable("root", this.rootVariable, rootSymbol?.type));
         const parameters = ast.params.map((parameter4, index) => {
+          this.assertLocalNameAvailable(parameter4.name, outerScope, parameter4.pos);
           this.assertLocalNameAvailable(parameter4.name, scope, parameter4.pos);
           const expectedType = requiredAt(expected.parameterTypes, index);
           const declared = parameter4.type ? this.resolveType(parameter4.type) : expectedType;
-          if (!isNeoScriptTypeAssignable(declared, expectedType, this.project) || !isNeoScriptTypeAssignable(expectedType, declared, this.project)) {
+          if (!isNeoScriptTypeAssignable(declared, expectedType, this.project)) {
+            throw new CompileError(
+              `Delegate lambda parameter ${index + 1} type ${this.describe(declared)} is not assignable to ${this.describe(expectedType)}.`,
+              parameter4.pos
+            );
+          }
+          if (!isNeoScriptTypeAssignable(expectedType, declared, this.project)) {
             throw new CompileError(
-              `Delegate lambda parameter ${index + 1} must be ${this.describe(expectedType)}, got ${this.describe(declared)}.`,
+              `Delegate lambda parameter ${index + 1} type ${this.describe(declared)} is broader than the declared delegate parameter ${this.describe(expectedType)}.`,
               parameter4.pos
             );
           }
           const item = variable(
-            `__arg_${index}__`,
+            `__lambda_${serial}_arg_${index}__`,
             declared,
             void 0,
             this.project
@@ -11251,6 +11344,14 @@ var init_strict_resolver = __esm({
           );
           return item;
         });
+        const captureContext = {
+          outerScope,
+          closureScope: scope,
+          serial,
+          captures: [],
+          byOuterEntry: /* @__PURE__ */ new Map()
+        };
+        this.delegateCaptureContexts.push(captureContext);
         this.functionControlBoundaries.push({
           controlDepth: this.controlContexts.length,
           loopFlowDepth: this.loopFlowContexts.length,
@@ -11269,11 +11370,34 @@ var init_strict_resolver = __esm({
           }
           const action = {
             compilerRevision: NEOSCRIPT_COMPILER_REVISION,
-            parameters: [this.thisVariable, this.rootVariable, ...parameters],
+            parameters: [
+              this.thisVariable,
+              this.rootVariable,
+              ...parameters,
+              ...captureContext.captures.map((capture) => capture.parameter)
+            ],
             instructions,
             typeInfo: returnsVoid ? toWireType({ kind: "primitive", name: "null" }, this.project) : toWireType(expected.returnType, this.project)
           };
           const code = this.delegateLambdaSource(ast);
+          if (captureContext.captures.length > 0) {
+            const typeInfo = toWireType(expected, this.project);
+            if (typeInfo.type !== 25 /* Delegate */) {
+              throw new Error(
+                "NeoScript delegate closure lowered with non-delegate type info."
+              );
+            }
+            return {
+              pointer: {
+                type: "delegateClosure" /* DelegateClosure */,
+                typeInfo,
+                action,
+                captures: captureContext.captures.map((capture) => capture.source),
+                ...code === void 0 ? {} : { code }
+              },
+              type: expected
+            };
+          }
           return literal(
             expected,
             code === void 0 ? { action } : { code, action },
@@ -11283,11 +11407,14 @@ var init_strict_resolver = __esm({
           this.expectedReturnStack.pop();
           this.lambdaDepth--;
           this.functionControlBoundaries.pop();
+          this.delegateCaptureContexts.pop();
         }
       }
       delegateLambdaSource(ast) {
-        if (this.source === void 0) return void 0;
-        const tokens = lex2(this.source);
+        if (this.source === void 0 || this.sourceTokens === void 0) {
+          return void 0;
+        }
+        const tokens = this.sourceTokens;
         const startIndex = tokens.findIndex(
           (token) => token.pos.line === ast.pos.line && token.pos.column === ast.pos.column
         );
@@ -11606,7 +11733,7 @@ var init_strict_resolver = __esm({
         };
       }
       resolveIdentifier(name, scope, pos) {
-        const entry = scope.lookup(name);
+        const entry = scope.lookup(name) ?? this.captureDelegateOuterBinding(name);
         if (entry) {
           const ownership = scope.ownership(entry) ?? entry.writability;
           return {
@@ -11659,6 +11786,52 @@ var init_strict_resolver = __esm({
         }
         throw new CompileError(`Unknown identifier '${name}'`, pos);
       }
+      /**
+       * Materializes one free delegate-lambda binding as an explicit trailing
+       * action parameter. The pointer stored beside it is evaluated once at the
+       * lambda expression site, giving NeoScript deterministic by-value capture
+       * semantics that survive return, assignment, and persistence.
+       */
+      captureDelegateOuterBinding(name) {
+        const context = this.delegateCaptureContexts.at(-1);
+        if (context === void 0) return null;
+        let outerEntry = context.outerScope.lookup(name);
+        if (outerEntry === null && this.delegateCaptureContexts.length > 1) {
+          const current = this.delegateCaptureContexts.pop();
+          try {
+            this.captureDelegateOuterBinding(name);
+          } finally {
+            if (current !== void 0) this.delegateCaptureContexts.push(current);
+          }
+          outerEntry = context.outerScope.lookup(name);
+        }
+        if (outerEntry === null) return null;
+        const existing = context.byOuterEntry.get(outerEntry);
+        if (existing !== void 0) return existing;
+        const parameter4 = variable(
+          `__capture_${context.serial}_${context.captures.length}__`,
+          outerEntry.type,
+          void 0,
+          this.project
+        );
+        const entry = scopeVariable(
+          name,
+          parameter4,
+          outerEntry.type,
+          "local" /* Local */,
+          "local" /* Local */,
+          outerEntry.writeRoot,
+          "capture"
+        );
+        const source = outerEntry.pointer ?? {
+          type: "variable" /* Variable */,
+          variableId: outerEntry.variableId
+        };
+        context.byOuterEntry.set(outerEntry, entry);
+        context.captures.push({ outerEntry, source, parameter: parameter4, entry });
+        context.closureScope.define(entry);
+        return entry;
+      }
       resolveContextualEnum(optionName, expected, pos) {
         if (!expected || expected.kind !== "named") {
           throw new CompileError(
@@ -12838,6 +13011,37 @@ var init_strict_resolver = __esm({
           );
         }
         const memberReceiverType = neoScriptMemberLookupType(receiver.type);
+        if (callee.name === "Equals" && memberReceiverType.kind === "typeParameter") {
+          if (optional) {
+            throw new CompileError(
+              "Equals cannot be optional-chained on a generic receiver; narrow it with a null check first.",
+              pos
+            );
+          }
+          if (isNullable(receiver.type)) {
+            throw new CompileError(
+              "Equals cannot be called on an optional generic receiver; narrow it with a null check first.",
+              pos
+            );
+          }
+          requireArgCount("Equals", argumentsList2, 1, pos);
+          const other = this.resolveExpression(
+            requiredAt(argumentsList2, 0),
+            scope,
+            { ...memberReceiverType, nullable: true }
+          );
+          return {
+            pointer: {
+              type: "callFunction" /* CallFunction */,
+              memberKey: "Equals",
+              receiver: { kind: "instance", pointer: receiver.pointer },
+              args: [other.pointer],
+              missingMemberFallback: "valueEquality",
+              callSiteId: this.nextCallSite(pos)
+            },
+            type: { kind: "primitive", name: "bool" }
+          };
+        }
         if (memberReceiverType.kind === "named") {
           const type = this.project.typeById.get(memberReceiverType.typeId);
           const member = type?.members.find(
@@ -14434,6 +14638,159 @@ var init_strict_resolver = __esm({
           args
         };
       }
+      /**
+       * `NeoAction.Clear()` resets the stored listener set. It lowers to an
+       * ordinary whole-member assignment so every existing write host observes
+       * the same overlay and write-intent contract as `+=` / `-=`.
+       */
+      resolveActionClear(expression, scope, pos) {
+        if (expression.kind !== "call" || expression.callee.kind !== "member" || expression.callee.name !== "Clear") {
+          return null;
+        }
+        const receiver = this.resolveExpression(expression.callee.receiver, scope);
+        if (receiver.type.kind !== "action") return null;
+        if (expression.callee.optional) {
+          throw new CompileError(
+            `${this.describe(receiver.type)} is never null, so optional-chained Clear is not supported.`,
+            pos
+          );
+        }
+        requireArgCount("Clear", expression.args, 0, pos);
+        if (!isActionMemberPointer(receiver.pointer)) {
+          throw new CompileError(
+            `Cannot clear ${this.describe(receiver.type)} that is not a member reference; an action is not a value. Clear it through the member reference directly.`,
+            pos
+          );
+        }
+        if (receiver.symbol?.computed === true) {
+          throw new CompileError(
+            `Cannot clear NeoScript property '${receiver.symbol.name}'; an action listener set must be stored data.`,
+            pos
+          );
+        }
+        const writability = receiver.writability;
+        if (writability === "immutable" /* Immutable */) {
+          throw new CompileError(
+            "Cannot clear an action whose effective storage is immutable.",
+            pos
+          );
+        }
+        if (!writability) {
+          throw new CompileError(
+            "Cannot clear an action whose member writability could not be resolved.",
+            pos
+          );
+        }
+        if (writability === "readOnly" /* ReadOnly */) {
+          throw new CompileError("Cannot clear a read-only action.", pos);
+        }
+        this.validateConstructorWriteTarget(
+          receiver.pointer,
+          "mutate",
+          pos,
+          scope,
+          true
+        );
+        const path = canonicalPath(expression.callee.receiver);
+        if (path) {
+          const rootEntry = scope.lookup(pathRoot(path));
+          if (rootEntry) scope.invalidate(rootEntry);
+        }
+        const actionTypeInfo = receiver.wireType ?? toWireType(receiver.type, this.project);
+        return {
+          type: "assign" /* Assign */,
+          target: {
+            pointer: receiver.pointer,
+            typeInfo: actionTypeInfo,
+            writability
+          },
+          operator: "=" /* Assign */,
+          pointer: {
+            type: "value" /* Value */,
+            value: { typeInfo: actionTypeInfo, value: { listeners: [] } }
+          }
+        };
+      }
+      resolveConditionalExpression(expression, scope, expected) {
+        const condition = this.toBool(
+          this.resolveExpression(expression.condition, scope),
+          expression.condition.pos
+        );
+        const trueScope = new Scope(scope);
+        this.applyFactsToScope(
+          scope,
+          trueScope,
+          factsWhenTrue(expression.condition)
+        );
+        const falseScope = new Scope(scope);
+        this.applyFactsToScope(
+          scope,
+          falseScope,
+          factsWhenFalse(expression.condition)
+        );
+        let whenTrue;
+        let whenFalse;
+        if (expected) {
+          whenTrue = this.resolveExpression(
+            expression.whenTrue,
+            trueScope,
+            expected
+          );
+          whenFalse = this.resolveExpression(
+            expression.whenFalse,
+            falseScope,
+            expected
+          );
+        } else if (expression.whenTrue.kind === "litNull" || expression.whenTrue.kind === "contextualEnum") {
+          whenFalse = this.resolveExpression(expression.whenFalse, falseScope);
+          whenTrue = this.resolveExpression(expression.whenTrue, trueScope, {
+            ...whenFalse.type,
+            nullable: true
+          });
+        } else {
+          whenTrue = this.resolveExpression(expression.whenTrue, trueScope);
+          whenFalse = this.resolveExpression(
+            expression.whenFalse,
+            falseScope,
+            expression.whenFalse.kind === "litNull" ? { ...whenTrue.type, nullable: true } : whenTrue.type
+          );
+        }
+        const common = commonNeoScriptAssignableType(
+          whenTrue.type,
+          whenFalse.type,
+          this.project
+        );
+        const resultType = common ?? (expected && isNeoScriptTypeAssignable(whenTrue.type, expected, this.project) && isNeoScriptTypeAssignable(whenFalse.type, expected, this.project) ? expected : null);
+        if (!resultType) {
+          throw new CompileError(
+            `Conditional branches ${this.describe(whenTrue.type)} and ${this.describe(whenFalse.type)} do not have a common assignable type.`,
+            expression.pos
+          );
+        }
+        if (expected) {
+          this.requireAssignable(
+            whenTrue.type,
+            expected,
+            expression.whenTrue.pos,
+            "conditional true branch"
+          );
+          this.requireAssignable(
+            whenFalse.type,
+            expected,
+            expression.whenFalse.pos,
+            "conditional false branch"
+          );
+        }
+        return {
+          pointer: {
+            type: "conditional" /* Conditional */,
+            condition: condition.pointer,
+            whenTrue: whenTrue.pointer,
+            whenFalse: whenFalse.pointer
+          },
+          type: resultType
+        };
+      }
       resolveBinary(expression, scope) {
         let left;
         let preResolvedRight;
@@ -14646,6 +15003,15 @@ var init_strict_resolver = __esm({
                 type.pos
               );
             }
+            const declaringTypeRef = this.context.declaringType ?? this.context.thisClass;
+            const declaringType = declaringTypeRef?.kind === "named" ? this.project.typeById.get(declaringTypeRef.typeId) : void 0;
+            const typeParameter2 = declaringType?.typeParameters?.find(
+              (candidate) => candidate.name === type.name
+            );
+            if (typeParameter2?.type.kind === "typeParameter") {
+              resolved = typeParameter2.type;
+              break;
+            }
             const builtin = namedPrimitive(type.name);
             if (builtin) {
               resolved = { kind: "primitive", name: builtin };
@@ -22148,6 +22514,11 @@ function collectIdentifierReads(expression, names) {
         walk(node.left, visible);
         walk(node.right, visible);
         return;
+      case "conditional":
+        walk(node.condition, visible);
+        walk(node.whenTrue, visible);
+        walk(node.whenFalse, visible);
+        return;
       case "unary":
       case "force":
       case "is":
@@ -23185,6 +23556,50 @@ function validateExpression(expression, expected, scope, environment, uri, range
     );
     return;
   }
+  if (expression.kind === "conditional") {
+    validateExpression(
+      expression.condition,
+      primitiveType("bool"),
+      scope,
+      environment,
+      uri,
+      range2,
+      diagnostics,
+      anchor
+    );
+    const trueType = inferExpressionType2(
+      expression.whenTrue,
+      scope,
+      environment
+    );
+    const falseType = inferExpressionType2(
+      expression.whenFalse,
+      scope,
+      environment
+    );
+    const branchType = expected ?? commonSemanticAssignableType(trueType, falseType);
+    validateExpression(
+      expression.whenTrue,
+      branchType,
+      scope,
+      environment,
+      uri,
+      range2,
+      diagnostics,
+      anchor
+    );
+    validateExpression(
+      expression.whenFalse,
+      branchType,
+      scope,
+      environment,
+      uri,
+      range2,
+      diagnostics,
+      anchor
+    );
+    return;
+  }
   if (expression.kind === "new") {
     const typeName = expression.className ?? expected?.name;
     const declaration = typeName ? environment.types.get(typeName) : void 0;
@@ -23493,13 +23908,19 @@ function substituteSemanticType(type, bindings) {
   return { ...type, arguments: argumentsList2 };
 }
 function semanticTypesAssignable(actual, expected) {
-  if (actual.name === expected.name) return true;
+  if (actual.name === "null") {
+    return expected.name === "null" || expected.nullable === true;
+  }
+  if (expected.name === "null") return false;
+  if (actual.name === expected.name) {
+    return actual.nullable !== true || expected.nullable === true;
+  }
   if (actual.name === "void") return false;
   if (actual.name === "int" && (expected.name === "float" || expected.name === "decimal")) {
-    return true;
+    return actual.nullable !== true || expected.nullable === true;
   }
   if (actual.name === "float" && expected.name === "decimal") {
-    return true;
+    return actual.nullable !== true || expected.nullable === true;
   }
   if (Object.prototype.hasOwnProperty.call(
     NEO_PROJECT_SOURCE_RECORD_CONTRACT.enums,
@@ -23507,12 +23928,42 @@ function semanticTypesAssignable(actual, expected) {
   )) {
     return false;
   }
-  const primitiveNames = /* @__PURE__ */ new Set(["bool", "int", "float", "decimal", "string"]);
-  if (primitiveNames.has(expected.name) && primitiveNames.has(actual.name)) {
+  if (SEMANTIC_PRIMITIVE_TYPE_NAMES.has(expected.name) && SEMANTIC_PRIMITIVE_TYPE_NAMES.has(actual.name)) {
     return false;
   }
   return true;
 }
+function commonSemanticAssignableType(left, right) {
+  if (left === void 0) return right;
+  if (right === void 0) return left;
+  if (left.name === "null" && right.name === "null") return left;
+  if (left.name === "null") return { ...right, nullable: true };
+  if (right.name === "null") return { ...left, nullable: true };
+  if (left.name === right.name) {
+    return {
+      ...left,
+      nullable: left.nullable === true || right.nullable === true
+    };
+  }
+  const leftRank = semanticNumericRank(left.name);
+  const rightRank = semanticNumericRank(right.name);
+  if (leftRank !== void 0 && rightRank !== void 0) {
+    const name = leftRank >= rightRank ? left.name : right.name;
+    return {
+      name,
+      nullable: left.nullable === true || right.nullable === true
+    };
+  }
+  if (semanticTypesAssignable(left, right)) return right;
+  if (semanticTypesAssignable(right, left)) return left;
+  return void 0;
+}
+function semanticNumericRank(name) {
+  if (name === "int") return 0;
+  if (name === "float") return 1;
+  if (name === "decimal") return 2;
+  return void 0;
+}
 function describeType(type) {
   const argumentsList2 = type.arguments?.length ? `<${type.arguments.map(describeType).join(", ")}>` : "";
   return `${type.name}${argumentsList2}${type.nullable ? "?" : ""}`;
@@ -23556,10 +24007,24 @@ function inferExpressionType2(expression, scope, environment) {
   if (expression.kind === "litBool") return primitiveType("bool");
   if (expression.kind === "litInt") return primitiveType("int");
   if (expression.kind === "litFloat") return primitiveType("float");
+  if (expression.kind === "litNull") return { name: "null", nullable: true };
   if (expression.kind === "litString" || expression.kind === "litInterp" || expression.kind === "litTripleString")
     return primitiveType("string");
   if (expression.kind === "new")
     return expression.className ? { name: expression.className } : void 0;
+  if (expression.kind === "conditional") {
+    const whenTrue = inferExpressionType2(
+      expression.whenTrue,
+      scope,
+      environment
+    );
+    const whenFalse = inferExpressionType2(
+      expression.whenFalse,
+      scope,
+      environment
+    );
+    return commonSemanticAssignableType(whenTrue, whenFalse);
+  }
   if (expression.kind === "member") {
     if (expression.receiver.kind === "ident" && environment.enums.has(expression.receiver.name)) {
       return { name: expression.receiver.name };
@@ -24073,7 +24538,7 @@ function classDerivesFromName(name, ancestorName, environment, seen = /* @__PURE
     return classDerivesFromName(base.name, ancestorName, environment, seen);
   });
 }
-var NEO_VARIANT_FOLDER_SETTING, primitiveType, IDENTIFIER_PATTERN, LIST_COLUMN_INHERITANCE_KEY;
+var NEO_VARIANT_FOLDER_SETTING, primitiveType, IDENTIFIER_PATTERN, LIST_COLUMN_INHERITANCE_KEY, SEMANTIC_PRIMITIVE_TYPE_NAMES;
 var init_project_source_semantics = __esm({
   "../packages/neoscript-language/src/project-source-semantics.ts"() {
     "use strict";
@@ -24090,6 +24555,13 @@ var init_project_source_semantics = __esm({
     primitiveType = (name) => ({ name });
     IDENTIFIER_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
     LIST_COLUMN_INHERITANCE_KEY = "__other__";
+    SEMANTIC_PRIMITIVE_TYPE_NAMES = /* @__PURE__ */ new Set([
+      "bool",
+      "int",
+      "float",
+      "decimal",
+      "string"
+    ]);
   }
 });
 
@@ -41658,6 +42130,32 @@ function isNSPointerCoalesce(value) {
   if (!isNSPointer(v.left)) return false;
   return isNSPointer(v.right);
 }
+function isNSPointerConditional(value) {
+  if (typeof value !== "object" || value === null) return false;
+  if (!("type" in value) || value.type !== "conditional" /* conditional */) {
+    return false;
+  }
+  if (!("condition" in value) || !isNSPointer(value.condition)) return false;
+  if (!("whenTrue" in value) || !isNSPointer(value.whenTrue)) return false;
+  return "whenFalse" in value && isNSPointer(value.whenFalse);
+}
+function isNSPointerDelegateClosure(value) {
+  if (typeof value !== "object" || value === null) return false;
+  if (!("type" in value) || value.type !== "delegateClosure" /* delegateClosure */) {
+    return false;
+  }
+  if (!("typeInfo" in value) || !isNSTypeInfo(value.typeInfo) || value.typeInfo.type !== 25 /* NSDelegate */) {
+    return false;
+  }
+  if (!("action" in value) || !isNSFunctionWithReturnType(value.action)) {
+    return false;
+  }
+  if (!("captures" in value) || !Array.isArray(value.captures) || !value.captures.every(isNSPointer)) {
+    return false;
+  }
+  if (!("code" in value) || value.code === void 0) return true;
+  return typeof value.code === "string" && value.code.length > 0;
+}
 function isNSPointerToBool(value) {
   const v = value;
   if (v?.type !== "toBool" /* toBool */) return false;
@@ -41685,6 +42183,12 @@ function isNSPointerCallFunction(value) {
   if (v.optional !== void 0 && typeof v.optional !== "boolean") {
     return false;
   }
+  if (v.missingMemberFallback !== void 0 && v.missingMemberFallback !== "valueEquality") {
+    return false;
+  }
+  if (v.missingMemberFallback === "valueEquality" && (!hasMemberKey || v.receiver?.kind !== "instance" || v.args.length !== 1)) {
+    return false;
+  }
   return true;
 }
 function isNSPointerCallDelegate(value) {
@@ -41725,7 +42229,7 @@ function isNSPointerFunctionErrorCheck(value) {
   return isNSFunctionErrorCheckMode(v.mode);
 }
 function isNSPointer(value) {
-  return isNSPointerReference(value) || isNSPointerVariable(value) || isNSPointerStaticMember(value) || isNSPointerValue(value) || isNSPointerOperation(value) || isNSPointerFunction(value) || isNSPointerKeyOf(value) || isNSPointerListLiteral(value) || isNSPointerDictLiteral(value) || isNSPointerForceUnwrap(value) || isNSPointerIsCheck(value) || isNSPointerCallGetter(value) || isNSPointerCoalesce(value) || isNSPointerToBool(value) || isNSPointerStringify(value) || isNSPointerCallFunction(value) || isNSPointerCallDelegate(value) || isNSPointerCallAction(value) || isNSPointerVariant(value) || isNSPointerFunctionErrorCheck(value);
+  return isNSPointerReference(value) || isNSPointerVariable(value) || isNSPointerStaticMember(value) || isNSPointerValue(value) || isNSPointerOperation(value) || isNSPointerFunction(value) || isNSPointerKeyOf(value) || isNSPointerListLiteral(value) || isNSPointerDictLiteral(value) || isNSPointerForceUnwrap(value) || isNSPointerIsCheck(value) || isNSPointerCallGetter(value) || isNSPointerCoalesce(value) || isNSPointerConditional(value) || isNSPointerDelegateClosure(value) || isNSPointerToBool(value) || isNSPointerStringify(value) || isNSPointerCallFunction(value) || isNSPointerCallDelegate(value) || isNSPointerCallAction(value) || isNSPointerVariant(value) || isNSPointerFunctionErrorCheck(value);
 }
 function isNSPointers(value) {
   return Array.isArray(value) && value.every(isNSPointer);
@@ -41794,24 +42298,7 @@ function isNSFunctionWithReturnType(value) {
   if (!Array.isArray(v.parameters)) return false;
   if (!v.parameters.every(isNSVariable)) return false;
   if (!isNSInstructions(v.instructions)) return false;
-  if ([
-    "for" /* for */,
-    "forEach" /* forEach */,
-    "break" /* break */,
-    "continue" /* continue */
-  ].some((type) => nsInstructionsContainType(v.instructions ?? [], type)) && (v.compilerRevision ?? 1) < 4) {
-    return false;
-  }
-  if (nsInstructionsContainType(v.instructions, "switch" /* switch */) && (v.compilerRevision ?? 1) < 5) {
-    return false;
-  }
-  if (nsInstructionsContainType(v.instructions, "try" /* try */) && (v.compilerRevision ?? 1) < 6) {
-    return false;
-  }
-  if ((v.compilerRevision ?? 1) < 8 && ([
-    "addActionListener" /* addActionListener */,
-    "removeActionListener" /* removeActionListener */
-  ].some((type) => nsInstructionsContainType(v.instructions ?? [], type)) || nsIRContainsPointerType(v.instructions, "callAction" /* callAction */))) {
+  if ((v.compilerRevision ?? 1) < NEOSCRIPT_COMPILER_REVISION && (v.compilerRevision ?? 1) < minimumNeoScriptCompilerRevisionForIR(v.instructions)) {
     return false;
   }
   if (!isNSTypeInfo(v.typeInfo)) return false;
@@ -42252,44 +42739,32 @@ function isNSInstructionTry(value) {
 function isNSInstruction(value) {
   return isNSInstructionVariable(value) || isNSInstructionIfBranch(value) || isNSInstructionReturn(value) || isNSInstructionThrow(value) || isNSInstructionAssign(value) || isNSInstructionCollectionCall(value) || isNSInstructionFunctionCall(value) || isNSInstructionFor(value) || isNSInstructionForEach(value) || isNSInstructionBreak(value) || isNSInstructionContinue(value) || isNSInstructionSwitch(value) || isNSInstructionTry(value) || isNSInstructionAddActionListener(value) || isNSInstructionRemoveActionListener(value);
 }
-function nsInstructionsContainType(instructions, type) {
-  return instructions.some((instruction) => {
-    if (instruction.type === type) return true;
-    if (instruction.type === "if" /* if */) {
-      return instruction.branches.some(
-        (branch) => nsInstructionsContainType(branch.instructions, type)
-      ) || instruction.else !== null && instruction.else !== void 0 && nsInstructionsContainType(instruction.else, type);
-    }
-    if (instruction.type === "for" /* for */ || instruction.type === "forEach" /* forEach */) {
-      return nsInstructionsContainType(instruction.instructions, type);
-    }
-    if (instruction.type === "switch" /* switch */) {
-      return instruction.sections.some(
-        (section) => nsInstructionsContainType(section.instructions, type)
-      ) || instruction.defaultInstructions !== null && instruction.defaultInstructions !== void 0 && nsInstructionsContainType(instruction.defaultInstructions, type);
-    }
-    if (instruction.type === "try" /* try */) {
-      return nsInstructionsContainType(instruction.instructions, type) || instruction.catches.some(
-        (clause) => nsInstructionsContainType(clause.instructions, type)
+function minimumNeoScriptCompilerRevisionForIR(node, visited = /* @__PURE__ */ new Set()) {
+  if (Array.isArray(node)) {
+    let minimum2 = 1;
+    for (const entry of node) {
+      minimum2 = Math.max(
+        minimum2,
+        minimumNeoScriptCompilerRevisionForIR(entry, visited)
       );
     }
-    return false;
-  });
-}
-function nsIRContainsPointerType(node, type, visited = /* @__PURE__ */ new Set()) {
-  if (Array.isArray(node)) {
-    return node.some((entry) => nsIRContainsPointerType(entry, type, visited));
+    return minimum2;
   }
-  if (typeof node !== "object" || node === null) return false;
-  if (visited.has(node)) return false;
+  if (typeof node !== "object" || node === null) return 1;
+  if (visited.has(node)) return 1;
   visited.add(node);
-  const record3 = node;
-  if (record3.type === type) return true;
-  const isLiteralValue = "typeInfo" in record3 && "value" in record3 && !("type" in record3);
-  return Object.entries(record3).some(([key, child]) => {
-    if (isLiteralValue && key === "value") return false;
-    return nsIRContainsPointerType(child, type, visited);
-  });
+  const discriminatorRevision = "type" in node && typeof node.type === "string" ? MINIMUM_REVISION_BY_IR_DISCRIMINATOR.get(node.type) ?? 1 : 1;
+  const fallbackRevision = "missingMemberFallback" in node && node.missingMemberFallback === "valueEquality" ? 12 : 1;
+  let minimum = Math.max(discriminatorRevision, fallbackRevision);
+  const isLiteralValue = "typeInfo" in node && "value" in node && !("type" in node);
+  for (const [key, child] of Object.entries(node)) {
+    if (isLiteralValue && key === "value") continue;
+    minimum = Math.max(
+      minimum,
+      minimumNeoScriptCompilerRevisionForIR(child, visited)
+    );
+  }
+  return minimum;
 }
 function isNSInstructions(value) {
   return Array.isArray(value) && value.every(isNSInstruction);
@@ -42337,7 +42812,7 @@ function isNSVoidBody(value) {
   if (value.typeInfo.type !== 0 /* Null */) return false;
   return value.typeInfo.required === true;
 }
-var NS_STRING_OPS, NS_DECIMAL_OPS, NS_MATH_OPS;
+var NS_STRING_OPS, NS_DECIMAL_OPS, NS_MATH_OPS, MINIMUM_REVISION_BY_IR_DISCRIMINATOR;
 var init_neoscript_guards = __esm({
   "../src/models/neoscript/neoscript-guards.ts"() {
     "use strict";
@@ -42370,6 +42845,20 @@ var init_neoscript_guards = __esm({
       "sign",
       "sqrt"
     ];
+    MINIMUM_REVISION_BY_IR_DISCRIMINATOR = /* @__PURE__ */ new Map([
+      ["for" /* for */, 4],
+      ["forEach" /* forEach */, 4],
+      ["break" /* break */, 4],
+      ["continue" /* continue */, 4],
+      ["switch" /* switch */, 5],
+      ["try" /* try */, 6],
+      ["callDelegate" /* callDelegate */, 7],
+      ["addActionListener" /* addActionListener */, 8],
+      ["removeActionListener" /* removeActionListener */, 8],
+      ["callAction" /* callAction */, 8],
+      ["conditional" /* conditional */, 12],
+      ["delegateClosure" /* delegateClosure */, 12]
+    ]);
   }
 });
 
@@ -43340,11 +43829,18 @@ function isNSDelegateClosureValueDraft(value) {
 function isNSDelegateClosureValue(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return false;
   const record3 = value;
-  const keys = record3.code === void 0 ? ["action"] : ["code", "action"];
+  const keys = [
+    ...record3.code === void 0 ? [] : ["code"],
+    "action",
+    ...record3.captures === void 0 ? [] : ["captures"]
+  ];
   if (!hasExactKeys(record3, keys)) return false;
   if (record3.code !== void 0 && (typeof record3.code !== "string" || record3.code.length === 0)) {
     return false;
   }
+  if (record3.captures !== void 0 && !Array.isArray(record3.captures)) {
+    return false;
+  }
   return isNSFunctionWithReturnType(record3.action);
 }
 function isNSDelegateValue(value) {
@@ -56100,6 +56596,17 @@ function expressionReadsRuntimeIdentifier(expression, runtimeIdentifiers) {
     case "binary":
     case "coalesce":
       return expressionReadsRuntimeIdentifier(expression.left, runtimeIdentifiers) || expressionReadsRuntimeIdentifier(expression.right, runtimeIdentifiers);
+    case "conditional":
+      return expressionReadsRuntimeIdentifier(
+        expression.condition,
+        runtimeIdentifiers
+      ) || expressionReadsRuntimeIdentifier(
+        expression.whenTrue,
+        runtimeIdentifiers
+      ) || expressionReadsRuntimeIdentifier(
+        expression.whenFalse,
+        runtimeIdentifiers
+      );
     case "unary":
     case "force":
     case "is":
@@ -56131,6 +56638,7 @@ function isEvaluatedOnlyExpression(expression) {
       return isEvaluatedOnlyExpression(expression.expression);
     case "binary":
     case "coalesce":
+    case "conditional":
     case "index":
     case "is":
     case "force":
@@ -67071,6 +67579,9 @@ function evalPointer(pointer, scope, ctx) {
         (arg) => evalPointer(arg, scope, ctx)
       );
       const member = pointer.receiver.kind === "static" ? evalMemberById(ctx.vm, pointer.receiver.memberId) : resolveEffectiveCallableMember(pointer, innerThis, ctx);
+      if (member !== null && pointer.missingMemberFallback === "valueEquality") {
+        assertValueEqualitySignature(member, innerThis, ctx);
+      }
       const args = fillCallableCallSiteArguments(suppliedArgs, member, ctx);
       const interceptedMemberId = member?.id ?? pointer.memberId ?? pointer.memberKey ?? pointer.callSiteId;
       consumeBudget(ctx, "workUnits", 1, "work unit");
@@ -67084,6 +67595,9 @@ function evalPointer(pointer, scope, ctx) {
       });
       if (intercepted?.handled === true) return intercepted.value;
       if (member === null) {
+        if (pointer.missingMemberFallback === "valueEquality") {
+          return jsEqual(innerThis, suppliedArgs[0]);
+        }
         throw new NSGetterRuntimeError(
           `Function call '${pointer.memberKey ?? pointer.memberId ?? pointer.callSiteId}' could not be resolved on the receiver's runtime class.`
         );
@@ -67197,6 +67711,24 @@ function evalPointer(pointer, scope, ctx) {
       if (left !== null && left !== void 0) return left;
       return evalPointer(pointer.right, scope, ctx);
     }
+    case "conditional" /* conditional */: {
+      const condition = evalPointer(pointer.condition, scope, ctx);
+      return evalPointer(
+        jsTruthy(condition) ? pointer.whenTrue : pointer.whenFalse,
+        scope,
+        ctx
+      );
+    }
+    case "delegateClosure" /* delegateClosure */:
+      return {
+        ...pointer.code === void 0 ? {} : { code: pointer.code },
+        action: pointer.action,
+        captures: pointer.captures.map(
+          (capture) => evalPointer(capture, scope, ctx)
+        ),
+        ...ctx.thisValue === null || ctx.thisValue === void 0 ? {} : { [DELEGATE_LEXICAL_THIS]: ctx.thisValue },
+        [DELEGATE_LEXICAL_ROOT]: ctx.rootValue
+      };
     case "toBool" /* toBool */: {
       const v = evalPointer(pointer.pointer, scope, ctx);
       return jsTruthy(v);
@@ -67225,6 +67757,34 @@ function resolveEffectiveCallableMember(pointer, receiver, ctx) {
   const runtimeMember = resolveRuntimeSchemaMember(receiver, schemaKey, ctx);
   return runtimeMember ?? staticMember;
 }
+function assertValueEqualitySignature(member, receiver, ctx) {
+  if (member.kind !== 13 /* Function */ && member.kind !== 23 /* NSFunction */) {
+    throw new NSGetterRuntimeError(
+      `Generic Equals resolved to non-callable member '${member.name}'.`
+    );
+  }
+  const signature = resolveCallableSignature(member.id, member.kind, ctx);
+  if (signature === null) {
+    throw new NSGetterRuntimeError(
+      `Generic Equals member '${member.name}' has no resolvable signature.`
+    );
+  }
+  const runtimeSignature = substituteCallableSignatureForReceiver(
+    signature,
+    receiver,
+    ctx
+  );
+  if (runtimeSignature.argumentTypes.length !== 1) {
+    throw new NSGetterRuntimeError(
+      `Generic Equals member '${member.name}' must take exactly one argument; found ${runtimeSignature.argumentTypes.length}.`
+    );
+  }
+  if (runtimeSignature.returnTypeInfo.type !== 1 /* Bool */) {
+    throw new NSGetterRuntimeError(
+      `Generic Equals member '${member.name}' must return bool.`
+    );
+  }
+}
 function invokeDelegateValue(value, args, ctx, callSiteId, ownerReceiver) {
   if (isNSDelegateClosureValueDraft(value)) {
     throw new NSGetterRuntimeError(
@@ -67234,6 +67794,7 @@ function invokeDelegateValue(value, args, ctx, callSiteId, ownerReceiver) {
   if (isNSDelegateClosureValue(value)) {
     const closure = value;
     const thisValue = delegateClosureLexicalThis(closure, ctx);
+    const captures = closure.captures ?? [];
     return executeCompiledFunction(
       value.action,
       {
@@ -67241,7 +67802,7 @@ function invokeDelegateValue(value, args, ctx, callSiteId, ownerReceiver) {
         thisValue,
         rootValue: closure[DELEGATE_LEXICAL_ROOT] ?? ctx.rootValue
       },
-      args,
+      [...args, ...captures],
       value.action.typeInfo.type === 0 /* Null */
     );
   }
@@ -112350,7 +112911,7 @@ var init_registry2 = __esm({
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
       formatVersion: 3,
       contractVersion: "3.13",
-      cliVersion: "0.32.4",
+      cliVersion: "0.33.0",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -118945,7 +119506,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.32.4");
+    console.log("0.33.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.32.4",
+  "version": "0.33.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.32.4 -->
+<!-- reviewed-through-cli: 0.33.0 -->
 
 # Neo Compose CLI
 

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.32.4 -->
+<!-- reviewed-through-cli: 0.33.0 -->
 ```
 
 The quoted version above is checked too, so this instruction cannot go stale

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

@@ -8,7 +8,7 @@ runtime ownership, evaluation, and migrations.
 - Inline bodies and snippets
 - Nullability and ownership
 - Numeric builtins
-- Logical operators
+- Conditional and logical operators
 - Loops and transfer
 - Switch
 - Try/catch
@@ -44,6 +44,20 @@ Prefer `--json` for automation.
 
 Inside an inline Class body, unqualified names resolve against that Class;
 invoke delegate and action members directly with `Selector()` or `OnChanged()`.
+Clear every subscribed listener from a stored action with
+`this.OnChanged.Clear()`. `Clear()` is a mutating statement and follows the
+action member's effective storage and writability.
+
+Inline `NeoDelegate` lambdas may be returned or stored and may read surrounding
+locals and parameters. Those values are captured when the lambda is created,
+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.
+
+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
+to ordinary NeoScript equality.
 
 ## Nullability and ownership
 
@@ -113,7 +127,17 @@ enum, parameter, or local may shadow it. Qualified members use their owner's
 namespace and may be named `Math`; access one as `this.Math` or
 `SomeValue.Math` without colliding with the builtin qualifier.
 
-## Logical operators
+## Conditional and logical operators
+
+Use `condition ? whenTrue : whenFalse` for a value chosen by a condition:
+
+```neo
+T modified = this.Modifier != null ? this.Modifier(value) : value;
+```
+
+The operator has lower precedence than `??`, `||`, and `&&`, associates from
+the right, and evaluates only the selected result arm. Both arms must share a
+common assignable type or fit the surrounding expected type.
 
 Use `&&` and `||` with C# precedence: `&&` binds tighter than `||`, and
 parentheses preserve explicit grouping. Both operators short-circuit, so the