@neocompose/cli 0.32.3 → 0.33.0

package/dist/neo.mjs

@@ -2833,12 +2833,6 @@ function referenceAtPosition(snapshot, position) {
     snapshot.source.offsetAt(position)
   );
 }
-function isValidNeoIdentifier(name) {
-  return IDENTIFIER_PATTERN.test(name) && !RESERVED_NAMES.has(name);
-}
-function isValidRenameIdentifier(name) {
-  return isValidNeoIdentifier(name);
-}
 function contextualCompletionItems(snapshot, offset, word) {
   const items = [];
   const expectedType = expectedTypeAt(snapshot, word.start);
@@ -4609,20 +4603,11 @@ function isConstructorTypeReference(snapshot, reference2) {
     (call) => call.kind === "constructor" && call.nameRange.start.line === reference2.range.start.line && call.nameRange.start.character === reference2.range.start.character
   );
 }
-var IDENTIFIER_PATTERN, RESERVED_NAMES;
 var init_analyzer = __esm({
   "../packages/neoscript-language/src/analyzer.ts"() {
     "use strict";
     init_language_spec();
     init_project();
-    IDENTIFIER_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
-    RESERVED_NAMES = /* @__PURE__ */ new Set([
-      ...NEOSCRIPT_KEYWORDS,
-      ...NEOSCRIPT_PRIMITIVE_TYPES,
-      ...NEOSCRIPT_BUILTIN_NAMESPACES,
-      "Dictionary",
-      "Set"
-    ]);
   }
 });
 
@@ -5923,10 +5908,22 @@ var init_strict_compile_error = __esm({
 function isValidNeoProjectIdentifier(name) {
   return PROJECT_IDENTIFIER_PATTERN.test(name) && !PROJECT_RESERVED_NAMES.has(name);
 }
+function isValidNeoProjectMemberIdentifier(name) {
+  return PROJECT_IDENTIFIER_PATTERN.test(name) && !PROJECT_MEMBER_RESERVED_NAMES.has(name);
+}
+function isValidNeoProjectBindingIdentifier(name) {
+  return PROJECT_IDENTIFIER_PATTERN.test(name) && !PROJECT_BINDING_RESERVED_NAMES.has(name);
+}
+function isValidNeoScriptBindingIdentifier(name) {
+  return PROJECT_IDENTIFIER_PATTERN.test(name) && !INLINE_BINDING_RESERVED_NAMES.has(name);
+}
 function isNeoProjectReservedName(name) {
   return PROJECT_RESERVED_NAMES.has(name);
 }
-var PROJECT_IDENTIFIER_PATTERN, PROJECT_RESERVED_NAMES;
+function isNeoProjectMemberReservedName(name) {
+  return PROJECT_MEMBER_RESERVED_NAMES.has(name);
+}
+var PROJECT_IDENTIFIER_PATTERN, PROJECT_RESERVED_NAMES, PROJECT_MEMBER_RESERVED_NAMES, PROJECT_BINDING_RESERVED_NAMES, INLINE_BINDING_RESERVED_NAMES;
 var init_project_source_identifiers = __esm({
   "../packages/neoscript-language/src/project-source-identifiers.ts"() {
     "use strict";
@@ -5936,6 +5933,20 @@ var init_project_source_identifiers = __esm({
       ...NEOSCRIPT_KEYWORDS,
       ...NEOSCRIPT_BUILTIN_NAMESPACES
     ]);
+    PROJECT_MEMBER_RESERVED_NAMES = new Set(NEOSCRIPT_KEYWORDS);
+    PROJECT_BINDING_RESERVED_NAMES = /* @__PURE__ */ new Set([
+      ...PROJECT_RESERVED_NAMES,
+      "this",
+      "root",
+      "context"
+    ]);
+    INLINE_BINDING_RESERVED_NAMES = /* @__PURE__ */ new Set([
+      ...PROJECT_BINDING_RESERVED_NAMES,
+      ...NEOSCRIPT_PRIMITIVE_TYPES,
+      "Dictionary",
+      "List",
+      "Set"
+    ]);
   }
 });
 
@@ -6456,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 === "%=");
@@ -6477,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";
@@ -6522,7 +6547,7 @@ var init_strict_parser = __esm({
       }
       expectMemberName() {
         const token = this.peek();
-        if (token.kind === "ident" || token.kind === "keyword" && (token.text === "native" || isValidNeoProjectIdentifier(token.text))) {
+        if (token.kind === "ident" || token.kind === "keyword" && (token.text === "native" || isValidNeoProjectMemberIdentifier(token.text))) {
           return this.next();
         }
         throw new CompileError(
@@ -6968,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();
@@ -7034,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
@@ -7092,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;
@@ -7527,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 };
@@ -7596,21 +7672,6 @@ var init_strict_parser = __esm({
         return { kind: "litInterp", parts, pos };
       }
     };
-    AST_BINARY_OPS = /* @__PURE__ */ new Set([
-      "+",
-      "-",
-      "*",
-      "/",
-      "%",
-      "==",
-      "!=",
-      "<",
-      ">",
-      "<=",
-      ">=",
-      "&&",
-      "||"
-    ]);
   }
 });
 
@@ -8214,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;
   }
 });
 
@@ -8617,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);
@@ -9504,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__",
@@ -9549,6 +9616,9 @@ var init_strict_resolver = __esm({
       argumentVariables;
       callSiteCounter = 0;
       lambdaDepth = 0;
+      delegateClosureCounter = 0;
+      delegateCaptureContexts = [];
+      sourceTokens;
       unreachableControlEffectDepth = 0;
       catchBindingCounter = 0;
       catchContexts = [];
@@ -10265,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,
@@ -10409,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
@@ -10568,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
@@ -11168,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);
@@ -11212,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} must be ${this.describe(expectedType)}, got ${this.describe(declared)}.`,
+              `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} 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
@@ -11240,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,
@@ -11258,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 },
@@ -11272,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
         );
@@ -11595,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 {
@@ -11648,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(
@@ -12827,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(
@@ -14423,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;
@@ -14635,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 };
@@ -17961,12 +18338,15 @@ function projectTokenAt(document, position) {
   const containing = tokens.find(
     (token) => token.start <= offset && offset < token.end
   );
-  if (containing?.kind === "identifier") return containing;
+  if (isProjectNameToken(containing)) return containing;
   const touching = tokens.find(
-    (token) => token.kind === "identifier" && token.end === offset
+    (token) => isProjectNameToken(token) && token.end === offset
   );
   return touching ?? containing;
 }
+function isProjectNameToken(token) {
+  return token !== void 0 && (token.kind === "identifier" || token.kind === "type" || token.kind === "keyword");
+}
 function projectTokens(document) {
   const cached = PROJECT_TOKEN_CACHE.get(document);
   if (cached) return cached;
@@ -18129,7 +18509,7 @@ function collectGlobalChildEntries(sourceText, declaration) {
       continue;
     }
     const name = tokens[index + 1];
-    if ((token.kind === "type" || token.kind === "identifier") && name?.kind === "identifier" && tokens[index + 2]?.text === "=" && tokens[index + 3]?.text !== "=" && // A pending annotation or statement boundary precedes a declaration;
+    if ((token.kind === "type" || token.kind === "identifier") && isProjectNameToken(name) && isValidNeoProjectMemberIdentifier(name.text) && tokens[index + 2]?.text === "=" && tokens[index + 3]?.text !== "=" && // A pending annotation or statement boundary precedes a declaration;
     // `key: value` fields and expression member accesses never do.
     tokens[index - 1]?.text !== "." && tokens[index - 1]?.text !== ":") {
       entries.push({
@@ -18184,6 +18564,7 @@ var init_project_source_registry = __esm({
   "../packages/neoscript-language/src/project-source-registry.ts"() {
     "use strict";
     init_lexer();
+    init_project_source_identifiers();
     init_project_source_tokens();
   }
 });
@@ -22133,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":
@@ -23170,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;
@@ -23478,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,
@@ -23492,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 ? "?" : ""}`;
@@ -23541,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 };
@@ -23869,7 +24349,7 @@ function memberKeyArgument(annotation2) {
   if (argument2 === void 0) return null;
   const text = argument2.text.trim();
   return {
-    key: IDENTIFIER_PATTERN2.test(text) ? text : null,
+    key: IDENTIFIER_PATTERN.test(text) ? text : null,
     range: argument2.range
   };
 }
@@ -24058,7 +24538,7 @@ function classDerivesFromName(name, ancestorName, environment, seen = /* @__PURE
     return classDerivesFromName(base.name, ancestorName, environment, seen);
   });
 }
-var NEO_VARIANT_FOLDER_SETTING, primitiveType, IDENTIFIER_PATTERN2, 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";
@@ -24073,8 +24553,15 @@ var init_project_source_semantics = __esm({
     init_project_root();
     NEO_VARIANT_FOLDER_SETTING = "folder";
     primitiveType = (name) => ({ name });
-    IDENTIFIER_PATTERN2 = /^[A-Za-z_][A-Za-z0-9_]*$/;
+    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"
+    ]);
   }
 });
 
@@ -27047,14 +27534,16 @@ function collectFlowSymbols(uri, content, ownerName, scopeRange, symbols, diagno
   }
 }
 function collectSymbol(uri, kind, name, range2, annotations, ownerName, symbols, diagnostics, scopeRange, detail, callable2, documentation, staticMember) {
-  if (isNeoProjectReservedName(name)) {
+  const memberLabel2 = kind === "member" || kind === "enumOption" || kind === "graphChild";
+  const reserved = memberLabel2 ? isNeoProjectMemberReservedName(name) : isNeoProjectReservedName(name);
+  if (reserved) {
     diagnostics.push({
       uri,
       range: range2,
       severity: "error",
       source: "neo-project",
       code: "reserved-project-name",
-      message: `'${name}' is a reserved Neo keyword and cannot be used as a persisted source name without the language's identifier escape syntax.`
+      message: `'${name}' is reserved in this Neo declaration context and cannot be used as a persisted source name without the language's identifier escape syntax.`
     });
   }
   const id2 = sourceId(uri, annotations, diagnostics);
@@ -28523,7 +29012,7 @@ function projectVariantScopeCompletion(analysis, document, position) {
 }
 function projectVariantPathSymbolAt(analysis, document, position) {
   const token = projectTokenAt(document, position);
-  if (!token || token.kind !== "identifier") return null;
+  if (!isProjectNameToken(token)) return null;
   const tokens = projectTokens(document);
   const tokenIndex = tokens.findIndex(
     (candidate) => candidate.start === token.start && candidate.end === token.end
@@ -28534,7 +29023,7 @@ function projectVariantPathSymbolAt(analysis, document, position) {
   for (; ; ) {
     const dot = tokens[cursor];
     const owner = tokens[cursor - 1];
-    if (dot?.text !== "." || owner?.kind !== "identifier") break;
+    if (dot?.text !== "." || !isProjectNameToken(owner)) break;
     segments.unshift(owner.text);
     cursor -= 2;
   }
@@ -29187,10 +29676,12 @@ function projectSemanticTokens(document, analysis) {
       return [];
     }
     const declaration = symbolsDeclaredAt(index, document.uri, token.range)[0];
-    const resolved = token.kind === "identifier" ? indexedProjectSymbolAt(analysis, document, token.range.start, index)?.symbol : void 0;
+    const resolved = isProjectNameToken(token) ? indexedProjectSymbolAt(analysis, document, token.range.start, index)?.symbol : void 0;
     let type;
     if (declaration) {
       type = projectSemanticTokenType(declaration);
+    } else if (resolved) {
+      type = projectSemanticTokenType(resolved);
     } else if (token.kind === "keyword") type = "keyword";
     else if (token.kind === "type") type = "type";
     else if (token.kind === "string") type = "string";
@@ -29242,7 +29733,14 @@ function projectSymbolAt(analysis, document, position) {
 }
 function indexedProjectSymbolAt(analysis, document, position, index) {
   const token = projectTokenAt(document, position);
-  if (!token || token.kind !== "identifier") return null;
+  if (!isProjectNameToken(token)) return null;
+  const body = projectBodySnapshotAt(analysis, document, position);
+  if (body) {
+    const reference2 = referenceAtPosition(body, position);
+    const symbolId = reference2 ? resolveReferenceSymbolId(body, reference2) : null;
+    const symbol = symbolId ? analysis.symbols.find((candidate) => candidate.id === symbolId) : void 0;
+    if (symbol) return { token, symbol };
+  }
   const exact = symbolsDeclaredAt(index, document.uri, token.range);
   if (exact.length === 1) return { token, symbol: exact[0] };
   const candidates = index.byName.get(token.text) ?? [];
@@ -29299,7 +29797,7 @@ function indexedProjectSymbolAt(analysis, document, position, index) {
       dotOwner.range.start,
       index
     );
-    const ownerNames = resolvedOwner ? projectReceiverOwnerNames(analysis, resolvedOwner.symbol) : [dotOwner.text];
+    const ownerNames = dotOwner.text === "this" && owner ? projectTypeAndBaseOwnerNames(analysis, owner) : resolvedOwner ? projectReceiverOwnerNames(analysis, resolvedOwner.symbol) : [dotOwner.text];
     const qualified = visibleCandidates.filter(
       (symbol) => symbol.ownerName !== void 0 && ownerNames.includes(symbol.ownerName) && (resolvedOwner === null || projectQualifiedSymbolMatchesReceiver(symbol, resolvedOwner.symbol))
     );
@@ -29334,27 +29832,33 @@ function projectQualifiedSymbolMatchesReceiver(symbol, receiver) {
 }
 function projectReceiverOwnerNames(analysis, receiver) {
   const result = [];
-  const visitedTypes = /* @__PURE__ */ new Set();
-  const appendTypeAndBases = (typeName2) => {
-    if (visitedTypes.has(typeName2)) return;
-    visitedTypes.add(typeName2);
-    if (!result.includes(typeName2)) result.push(typeName2);
-    const declaration = findTypeDeclaration(analysis, typeName2);
+  if (receiver.kind === "global") {
+    result.push(receiver.name);
+  }
+  const typeName = projectSymbolTypeName(receiver);
+  if (typeName)
+    result.push(...projectTypeAndBaseOwnerNames(analysis, typeName));
+  return result;
+}
+function projectTypeAndBaseOwnerNames(analysis, typeName) {
+  const result = [];
+  const visited = /* @__PURE__ */ new Set();
+  const append = (candidateName) => {
+    if (visited.has(candidateName)) return;
+    visited.add(candidateName);
+    result.push(candidateName);
+    const declaration = findTypeDeclaration(analysis, candidateName);
     if (declaration?.kind !== "class" && declaration?.kind !== "interface") {
       return;
     }
     for (const base of declaration.baseTypes) {
       const resolved = findTypeDeclaration(analysis, base.name);
       if (resolved?.kind === "class" || resolved?.kind === "interface") {
-        appendTypeAndBases(base.name);
+        append(base.name);
       }
     }
   };
-  if (receiver.kind === "global") {
-    result.push(receiver.name);
-  }
-  const typeName = projectSymbolTypeName(receiver);
-  if (typeName) appendTypeAndBases(typeName);
+  append(typeName);
   return result;
 }
 function contextualProjectEnumOptionSymbol(analysis, document, token, candidates, source) {
@@ -33099,6 +33603,8 @@ var init_service = __esm({
     init_analyzer();
     init_compiler();
     init_formatter();
+    init_generated_csharp_identifiers();
+    init_project_source_identifiers();
     init_project_source_analysis();
     init_project_source_construction_quick_fixes();
     init_project_source_language_features();
@@ -33320,9 +33826,25 @@ var init_service = __esm({
         return { range: reference2.range, placeholder: reference2.name };
       }
       rename(uri, position, newName) {
-        if (!isValidRenameIdentifier(newName)) {
+        const state = this.requireState(uri);
+        let validName;
+        if (isProjectDocument(state.document, state.context)) {
+          const resolved = projectSymbolAt(
+            this.projectAnalysis(),
+            state.document,
+            position
+          );
+          if (!resolved) return null;
+          const memberLabel2 = resolved.symbol.kind === "member" || resolved.symbol.kind === "enumOption" || resolved.symbol.kind === "graphChild";
+          const binding = resolved.symbol.kind === "parameter" || resolved.symbol.kind === "genericParameter" || resolved.symbol.kind === "flowBinding";
+          const validNeoName = memberLabel2 ? isValidNeoProjectMemberIdentifier(newName) : binding ? isValidNeoProjectBindingIdentifier(newName) : isValidNeoProjectIdentifier(newName);
+          validName = validNeoName && isGeneratedCSharpIdentifier(newName) && !isGeneratedCSharpReservedKeyword(newName);
+        } else {
+          validName = isValidNeoScriptBindingIdentifier(newName);
+        }
+        if (!validName) {
           throw new Error(
-            `Cannot rename a NeoScript symbol to "${newName}": use a non-keyword identifier containing letters, digits, or underscores.`
+            `Cannot rename a NeoScript symbol to "${newName}": use an identifier valid in this declaration context and generated C#.`
           );
         }
         const prepared = this.prepareRename(uri, position);
@@ -33422,7 +33944,7 @@ var init_service = __esm({
       }
       projectReferences(document, position, includeDeclaration) {
         const token = projectTokenAt(document, position);
-        if (!token || token.kind !== "identifier") return [];
+        if (!isProjectNameToken(token)) return [];
         const analysis = this.projectAnalysis();
         const resolved = projectSymbolAt(analysis, document, position);
         if (!resolved) return [];
@@ -33431,7 +33953,7 @@ var init_service = __esm({
         for (const state of this.documents.values()) {
           if (!isProjectDocument(state.document, state.context)) continue;
           for (const candidate of projectTokens(state.document)) {
-            if (candidate.kind !== "identifier" || candidate.text !== token.text) {
+            if (!isProjectNameToken(candidate) || candidate.text !== token.text) {
               continue;
             }
             const candidateSymbol = projectSymbolAt(
@@ -41184,6 +41706,46 @@ var init_docs_text2 = __esm({
   }
 });
 
+// ../src/models/project-source-identifiers.ts
+function isValidGeneratedIdentifier(value) {
+  return typeof value === "string" && isGeneratedCSharpIdentifier(value) && !isGeneratedCSharpReservedKeyword(value);
+}
+function isValidProjectSourceIdentifier(value) {
+  return isValidGeneratedIdentifier(value) && isValidNeoProjectIdentifier(value);
+}
+function isValidProjectMemberIdentifier(value) {
+  return isValidGeneratedIdentifier(value) && isValidNeoProjectMemberIdentifier(value);
+}
+function isValidProjectBindingIdentifier(value) {
+  return isValidGeneratedIdentifier(value) && isValidNeoProjectBindingIdentifier(value);
+}
+var init_project_source_identifiers2 = __esm({
+  "../src/models/project-source-identifiers.ts"() {
+    "use strict";
+    init_src();
+  }
+});
+
+// ../src/models/schema-identifiers.ts
+function isValidSchemaAuthoredIdentifier(value) {
+  return isValidProjectSourceIdentifier(value);
+}
+function isValidSchemaMemberIdentifier(value) {
+  return isValidProjectMemberIdentifier(value);
+}
+function isValidSchemaBindingIdentifier(value) {
+  return isValidProjectBindingIdentifier(value);
+}
+function isValidSchemaNSFunctionBindingIdentifier(value) {
+  return isValidSchemaBindingIdentifier(value) && value !== "value";
+}
+var init_schema_identifiers = __esm({
+  "../src/models/schema-identifiers.ts"() {
+    "use strict";
+    init_project_source_identifiers2();
+  }
+});
+
 // ../src/models/neoscript/neoscript-types.ts
 var NS_TYPE_UNKNOWN, NS_TYPE_VOID, NSAssignmentOperator, NSWritability, NSCollectionMutation;
 var init_neoscript_types = __esm({
@@ -41568,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;
@@ -41595,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) {
@@ -41635,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);
@@ -41704,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;
@@ -42162,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);
@@ -42247,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";
@@ -42280,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]
+    ]);
   }
 });
 
@@ -42755,12 +43334,20 @@ function isMemberAccessModifierKind(value) {
   if (value === "protected") return true;
   return value === "private";
 }
-function isValidCallableIdentifier(value) {
-  if (typeof value !== "string") return false;
-  if (!FunctionMemberNamePattern.test(value)) return false;
+function isValidCallableMemberIdentifier(value) {
+  if (!isValidSchemaMemberIdentifier(value)) return false;
+  if (value.startsWith("__")) return false;
+  return true;
+}
+function isValidCallableArgumentIdentifier(value) {
+  if (!isValidSchemaBindingIdentifier(value)) return false;
   if (value.startsWith("__")) return false;
   return !FunctionArgumentReservedNames.has(value);
 }
+function isValidNSFunctionArgumentIdentifier(value) {
+  if (!isValidSchemaNSFunctionBindingIdentifier(value)) return false;
+  return !value.startsWith("__");
+}
 function isMemberListColumnSettings(value) {
   if (!value) return false;
   if (typeof value !== "object") return false;
@@ -43124,7 +43711,7 @@ function isMemberAudioBase(value) {
 function isMemberFunctionBase(value) {
   const v = asMemberBaseForKind(value, 13 /* Function */);
   if (v === null) return false;
-  if (!isValidCallableIdentifier(v.name)) return false;
+  if (!isValidCallableMemberIdentifier(v.name)) return false;
   if (!isNSFunctionReturnTypeInfo(v.returnTypeInfo)) return false;
   if (!Array.isArray(v.argumentTypes)) return false;
   if (typeof v.deferred !== "boolean") return false;
@@ -43132,7 +43719,7 @@ function isMemberFunctionBase(value) {
   const argumentTypes = [];
   for (const arg of v.argumentTypes) {
     if (!isNSFunctionArgumentTypeInfo(arg)) return false;
-    if (!isValidCallableIdentifier(arg.name)) return false;
+    if (!isValidCallableArgumentIdentifier(arg.name)) return false;
     if (arg.type === NS_TYPE_UNKNOWN) return false;
     if (names.has(arg.name)) return false;
     names.add(arg.name);
@@ -43178,7 +43765,7 @@ function isNSFunctionUIBody(value) {
 function isMemberNSFunctionBase(value) {
   const v = asMemberBaseForKind(value, 23 /* NSFunction */);
   if (v === null) return false;
-  if (!isValidCallableIdentifier(v.name)) return false;
+  if (!isValidCallableMemberIdentifier(v.name)) return false;
   if (v.required !== false) return false;
   if (v.defaultValue !== void 0 && v.defaultValue !== null) return false;
   if (v.storage !== void 0 && v.storage !== null) return false;
@@ -43194,8 +43781,7 @@ function isMemberNSFunctionBase(value) {
   for (const argument2 of v.argumentTypes) {
     if (!isNSFunctionArgumentTypeInfo(argument2)) return false;
     if (argument2.type === NS_TYPE_UNKNOWN) return false;
-    if (!isValidCallableIdentifier(argument2.name)) return false;
-    if (NSFunctionArgumentReservedNames.has(argument2.name)) return false;
+    if (!isValidNSFunctionArgumentIdentifier(argument2.name)) return false;
     if (names.has(argument2.name)) return false;
     names.add(argument2.name);
     argumentTypes.push(argument2);
@@ -43243,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) {
@@ -43273,7 +43866,7 @@ function isMemberDelegateBase(value) {
   const names = /* @__PURE__ */ new Set();
   for (const argument2 of v.argumentTypes) {
     if (!isNSFunctionArgumentTypeInfo(argument2)) return false;
-    if (!isValidCallableIdentifier(argument2.name)) return false;
+    if (!isValidCallableArgumentIdentifier(argument2.name)) return false;
     if (argument2.type === NS_TYPE_UNKNOWN) return false;
     if (names.has(argument2.name)) return false;
     names.add(argument2.name);
@@ -43312,7 +43905,7 @@ function isMemberActionBase(value) {
   const names = /* @__PURE__ */ new Set();
   for (const argument2 of v.argumentTypes) {
     if (!isNSFunctionArgumentTypeInfo(argument2)) return false;
-    if (!isValidCallableIdentifier(argument2.name)) return false;
+    if (!isValidCallableArgumentIdentifier(argument2.name)) return false;
     if (argument2.type === NS_TYPE_UNKNOWN) return false;
     if (names.has(argument2.name)) return false;
     names.add(argument2.name);
@@ -43616,7 +44209,7 @@ function isMemberOverrideProps(value) {
   if (v.setter !== void 0 && !isNSVoidBody(v.setter)) return false;
   const isCallableOverride = v.kind === 13 /* Function */ || v.kind === 23 /* NSFunction */;
   if (isCallableOverride) {
-    if (!isValidCallableIdentifier(v.name)) return false;
+    if (!isValidCallableMemberIdentifier(v.name)) return false;
     if (v.returnTypeInfo !== void 0) return false;
     if (v.argumentTypes !== void 0) return false;
     if (v.deferred !== void 0) return false;
@@ -43693,37 +44286,23 @@ function isAnyMember(value) {
 function isAnyMemberAuthoredOrCompiled(value) {
   return isAnyMember(value) || isUncompiledMemberNSFunctionOverride(value);
 }
-var FunctionMemberNamePattern, FunctionArgumentReservedNames, NSFunctionArgumentReservedNames, DECIMAL_STRING_PATTERN, DECIMAL_MAX_SIGNIFICANT_DIGITS, DECIMAL_MAX_SCALE;
+var FunctionArgumentReservedNames, NSFunctionArgumentReservedNames, DECIMAL_STRING_PATTERN, DECIMAL_MAX_SIGNIFICANT_DIGITS, DECIMAL_MAX_SCALE;
 var init_member_kinds = __esm({
   "../src/models/members/member-kinds.ts"() {
     "use strict";
     init_core();
     init_docs_text2();
+    init_schema_identifiers();
     init_neoscript();
     init_classes();
     init_member_kind_enum();
     init_member_storage();
     init_structured_leaf_fields();
     init_member_kind_enum();
-    FunctionMemberNamePattern = /^[A-Za-z_][A-Za-z0-9_]*$/;
     FunctionArgumentReservedNames = /* @__PURE__ */ new Set([
       "this",
       "root",
-      "context",
-      "true",
-      "false",
-      "null",
-      "void",
-      "if",
-      "else",
-      "return",
-      "throw",
-      "var",
-      "int",
-      "float",
-      "decimal",
-      "string",
-      "bool"
+      "context"
     ]);
     NSFunctionArgumentReservedNames = /* @__PURE__ */ new Set([
       ...FunctionArgumentReservedNames,
@@ -47819,28 +48398,6 @@ var init_files = __esm({
   }
 });
 
-// ../src/models/project-source-identifiers.ts
-function isValidProjectSourceIdentifier(value) {
-  return typeof value === "string" && isValidNeoProjectIdentifier(value) && isGeneratedCSharpIdentifier(value) && !isGeneratedCSharpReservedKeyword(value);
-}
-var init_project_source_identifiers2 = __esm({
-  "../src/models/project-source-identifiers.ts"() {
-    "use strict";
-    init_src();
-  }
-});
-
-// ../src/models/schema-identifiers.ts
-function isValidSchemaAuthoredIdentifier(value) {
-  return isValidProjectSourceIdentifier(value);
-}
-var init_schema_identifiers = __esm({
-  "../src/models/schema-identifiers.ts"() {
-    "use strict";
-    init_project_source_identifiers2();
-  }
-});
-
 // ../src/models/enum/enum-types.ts
 function isValidEnumOptionId(id2) {
   if (typeof id2 !== "string" || id2.length === 0) return false;
@@ -47852,7 +48409,7 @@ function isProspectiveEnumOptionId(id2) {
   return isValidEnumOptionId(id2);
 }
 function isValidEnumOptionName(name) {
-  return isValidSchemaAuthoredIdentifier(name);
+  return isValidSchemaMemberIdentifier(name);
 }
 function isEnumOptionWithIds(value, isOptionId) {
   const v = value;
@@ -50794,14 +51351,14 @@ function listAnnotations(member) {
   if (member.kind !== "list") return [];
   return [
     ...member.indexes.map((entry) => {
-      assertIdentifier(entry.schemaKey, "list index member");
+      assertMemberIdentifier(entry.schemaKey, "list index member");
       return `@index(${[
         `member: ${entry.schemaKey}`,
         ...entry.unique ? ["unique: true"] : []
       ].join(", ")})`;
     }),
     ...member.columns.map((entry) => {
-      assertIdentifier(entry.memberKey, "list column member");
+      assertMemberIdentifier(entry.memberKey, "list column member");
       return `@column(${[
         `member: ${entry.memberKey}`,
         ...entry.width === null ? [] : [`width: ${entry.width}`],
@@ -51236,7 +51793,7 @@ function renderNestedValue(context, member, value) {
   return renderDefaultValue(context, member, { value, classId: null });
 }
 function emitTextureTemplate(value) {
-  assertIdentifier(value.name, "texture template");
+  assertProjectIdentifier(value.name, "texture template");
   const platformSettings = `new(
 ${namedArguments(
     [
@@ -51429,7 +51986,7 @@ function emitVector4(value) {
   return `new(x: ${value.x}, y: ${value.y}, z: ${value.z}, w: ${value.w})`;
 }
 function emitAudioTemplate(value) {
-  assertIdentifier(value.name, "audio template");
+  assertProjectIdentifier(value.name, "audio template");
   const enumArguments = /* @__PURE__ */ new Set([
     "loadType",
     "compressionFormat",
@@ -51634,7 +52191,7 @@ function emitVariantFiles(context, variantInitializers) {
 function emitVariantFolder(context, className, folder) {
   for (const segment of folder.path.split("/")) {
     if (segment.length === 0) continue;
-    assertIdentifier(segment, "variant folder path segment");
+    assertProjectIdentifier(segment, "variant folder path segment");
   }
   if (folder.binding === null) {
     return `${id(folder.id)}NeoVariantFolder<${className}> ${variantFolderSymbol(folder)} = new(${quote(folder.path)});`;
@@ -51654,7 +52211,7 @@ function emitVariantFolder(context, className, folder) {
 );`;
 }
 function emitVariant(context, className, variant, folder, variantInitializers) {
-  assertIdentifier(variant.name, "variant");
+  assertProjectIdentifier(variant.name, "variant");
   const initializer = variantInitializers.get(variant.id);
   if (initializer === void 0) {
     throw new Error(
@@ -51709,13 +52266,20 @@ function assertUniqueEmittedPaths(files) {
     paths.set(key, file);
   }
 }
-function assertIdentifier(value, kind) {
-  if (!isValidNeoIdentifier(value)) {
+function assertProjectIdentifier(value, kind) {
+  if (!isValidNeoProjectIdentifier(value)) {
     throw new Error(
       `Persisted ${kind} name ${quote(value)} is not a valid Neo identifier; repair the server record before format-4 conversion.`
     );
   }
 }
+function assertMemberIdentifier(value, kind) {
+  if (!isValidNeoProjectMemberIdentifier(value)) {
+    throw new Error(
+      `Persisted ${kind} name ${quote(value)} is not a valid Neo member identifier; repair the server record before format-4 conversion.`
+    );
+  }
+}
 function required(map, key, kind) {
   const value = map.get(key);
   if (!value) throw new Error(`Unknown ${kind} ${quote(key)}.`);
@@ -51829,7 +52393,7 @@ function assignDeterministicProjectFileSymbols(files, reservedSymbols = []) {
     const candidate = `${item.base}${collidesByStem ? item.extension : ""}`;
     let symbol = candidate;
     let suffix = 2;
-    while (used.has(symbol.toLowerCase()) || !isValidNeoIdentifier(symbol))
+    while (used.has(symbol.toLowerCase()) || !isValidNeoProjectMemberIdentifier(symbol))
       symbol = `${candidate}_${suffix++}`;
     used.add(symbol.toLowerCase());
     result.set(item.stableId, symbol);
@@ -52450,7 +53014,7 @@ ${args.map(([name, value]) => `  ${name}: ${value},`).join("\n")}
 `;
 }
 function emitPriorityGroup(data, recordId, name) {
-  assertIdentifier2(name, "priority group");
+  assertProjectIdentifier2(name, "priority group");
   const options = Array.isArray(data.options) ? data.options : [];
   const body = options.map((option, index) => {
     if (!isObjectRecord2(option) || typeof option.id !== "string" || typeof option.name !== "string") {
@@ -52458,7 +53022,7 @@ function emitPriorityGroup(data, recordId, name) {
         `Priority group ${recordId} option ${index} is malformed.`
       );
     }
-    assertIdentifier2(option.name, "priority option");
+    assertMemberIdentifier2(option.name, "priority option");
     return `  @id(${quote2(option.id)})
   PriorityOption ${option.name} = new();`;
   });
@@ -52473,7 +53037,7 @@ ${body.join("\n\n")}
 `;
 }
 function emitDialogueGroup(data, recordId, name, priorityNames, dialogueNames, uiLogicResolver) {
-  assertIdentifier2(name, "dialogue group");
+  assertProjectIdentifier2(name, "dialogue group");
   const kind = data.type === 1 ? "Lookup" : data.type === 2 ? "Folder" : "Standard";
   const args = [["kind", `.${kind}`]];
   const priority = reference(
@@ -52545,7 +53109,7 @@ function collectDialogueGroupFunctions(data, groupId, resolver) {
     let functionName = functionNameById.get(functionId);
     const code = typeof value.code === "string" ? value.code.trim() : value.type === 0 ? uiConditionSource(value.getter, resolver) : null;
     if (functionName === void 0) {
-      assertIdentifier2(requestedName, "dialogue group function");
+      assertMemberIdentifier2(requestedName, "dialogue group function");
       functionName = uniqueIdentifier(requestedName, names);
       functions.set(functionId, { id: functionId, name: functionName, code });
       functionNameById.set(functionId, functionName);
@@ -53107,7 +53671,7 @@ function requiredName(data, record3) {
   if (typeof data.name !== "string") {
     throw new Error(`${record3.recordKind}:${record3.recordId} has no name.`);
   }
-  assertIdentifier2(data.name, record3.recordKind);
+  assertProjectIdentifier2(data.name, record3.recordKind);
   return data.name;
 }
 function namesById(records2, kind) {
@@ -53199,7 +53763,7 @@ function normalizeSource(value) {
   return value.replace(/\s+/gu, " ").trim();
 }
 function isIdentifier(value) {
-  return /^[A-Za-z_][A-Za-z0-9_]*$/u.test(value);
+  return isValidNeoProjectMemberIdentifier(value);
 }
 function reference(value, names, type) {
   if (value === void 0 || value === null) return null;
@@ -53250,13 +53814,20 @@ function enumCase2(value) {
 function lowerFirst2(value) {
   return `${value[0]?.toLowerCase() ?? ""}${value.slice(1)}`;
 }
-function assertIdentifier2(value, kind) {
-  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(value)) {
+function assertProjectIdentifier2(value, kind) {
+  if (!isValidNeoProjectIdentifier(value)) {
     throw new Error(
       `${kind} name ${JSON.stringify(value)} is not a valid Neo identifier.`
     );
   }
 }
+function assertMemberIdentifier2(value, kind) {
+  if (!isValidNeoProjectMemberIdentifier(value)) {
+    throw new Error(
+      `${kind} name ${JSON.stringify(value)} is not a valid Neo member identifier.`
+    );
+  }
+}
 function uniqueIdentifier(requested, used) {
   let candidate = requested;
   let suffix = 2;
@@ -53967,6 +54538,7 @@ var init_interface_validation = __esm({
   "../src/models/interfaces/interface-validation.ts"() {
     "use strict";
     init_member_kinds();
+    init_schema_identifiers();
     init_interface_conformance();
     init_interface_graph();
   }
@@ -56024,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":
@@ -56055,6 +56638,7 @@ function isEvaluatedOnlyExpression(expression) {
       return isEvaluatedOnlyExpression(expression.expression);
     case "binary":
     case "coalesce":
+    case "conditional":
     case "index":
     case "is":
     case "force":
@@ -66995,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");
@@ -67008,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.`
         );
@@ -67121,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);
@@ -67149,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(
@@ -67158,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,
       {
@@ -67165,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 */
     );
   }
@@ -72799,22 +73436,22 @@ var init_init_backed_value_materialization = __esm({
 function hasRejectedConstructorKey(value) {
   return REJECTED_CONSTRUCTOR_KEYS.some((key) => value[key] !== void 0);
 }
-function isNamedBaseClauseEntry(value) {
+function isNamedBaseClauseEntry(value, nameIsValid) {
   if (typeof value !== "object" || value === null) return false;
   if (Array.isArray(value)) return false;
   const candidate = value;
   if (!Object.keys(candidate).every((key) => key === "name" || key === "code")) {
     return false;
   }
-  if (!isValidCallableIdentifier(candidate.name)) return false;
+  if (!nameIsValid(candidate.name)) return false;
   if (typeof candidate.code !== "string") return false;
   return candidate.code.length > 0;
 }
 function isNeoConstructorBaseArgument(value) {
-  return isNamedBaseClauseEntry(value);
+  return isNamedBaseClauseEntry(value, isValidCallableArgumentIdentifier);
 }
 function isNeoConstructorBaseInitializerField(value) {
-  return isNamedBaseClauseEntry(value);
+  return isNamedBaseClauseEntry(value, isValidSchemaMemberIdentifier);
 }
 function isNeoClassConstructorBase(value) {
   if (typeof value !== "object" || value === null) return false;
@@ -72830,7 +73467,7 @@ function isNeoClassConstructorBase(value) {
   const argumentTypes = [];
   for (const argument2 of v.argumentTypes) {
     if (!isNSFunctionArgumentTypeInfo(argument2)) return false;
-    if (!isValidCallableIdentifier(argument2.name)) return false;
+    if (!isValidCallableArgumentIdentifier(argument2.name)) return false;
     if (parameterNames.has(argument2.name)) return false;
     parameterNames.add(argument2.name);
     argumentTypes.push(argument2);
@@ -72929,6 +73566,7 @@ var init_constructors = __esm({
     init_core();
     init_docs_text2();
     init_member_kinds();
+    init_schema_identifiers();
     init_neoscript();
     REJECTED_CONSTRUCTOR_KEYS = [
       "bodyMode",
@@ -83113,8 +83751,20 @@ function stableValue(value) {
 function stableTypeInfo(value) {
   return JSON.stringify(stableValue(value));
 }
-function isOpaqueCallableIdentifier(value) {
-  return typeof value === "string" && OPAQUE_CALLABLE_IDENTIFIER_PATTERN.test(value) && !value.startsWith("__") && !OPAQUE_CALLABLE_RESERVED_NAMES.has(value);
+function isOpaqueGeneratedIdentifier(value, neoPredicate) {
+  return typeof value === "string" && neoPredicate(value) && isGeneratedCSharpIdentifier(value) && !isGeneratedCSharpReservedKeyword(value);
+}
+function isOpaqueSchemaMemberIdentifier(value) {
+  return isOpaqueGeneratedIdentifier(value, isValidNeoProjectMemberIdentifier);
+}
+function isOpaqueCallableMemberIdentifier(value) {
+  return isOpaqueSchemaMemberIdentifier(value) && !value.startsWith("__");
+}
+function isOpaqueCallableArgumentIdentifier(value) {
+  return isOpaqueGeneratedIdentifier(value, isValidNeoProjectBindingIdentifier) && !value.startsWith("__");
+}
+function isOpaqueNSFunctionArgumentIdentifier(value) {
+  return isOpaqueCallableArgumentIdentifier(value) && value !== "value";
 }
 function isOpaqueNSTypeInfo(value, ancestors = /* @__PURE__ */ new Set()) {
   if (!isRecord7(value) || typeof value.required !== "boolean") return false;
@@ -83208,11 +83858,11 @@ function isOpaqueNSFunctionReturnTypeInfo(value) {
   return isOpaqueNSTypeInfo(value);
 }
 function isOpaqueNSFunctionArgumentTypeInfo(value) {
-  return isOpaqueNSTypeInfo(value) && isOpaqueCallableIdentifier(value.name) && !opaqueTypeInfoContainsUnknown(value) && hasValidOpaqueParameterDefault(value);
+  return isOpaqueNSTypeInfo(value) && isOpaqueNSFunctionArgumentIdentifier(value.name) && !opaqueTypeInfoContainsUnknown(value) && hasValidOpaqueParameterDefault(value);
 }
 function isOpaqueConstructorArgumentTypeInfo(value) {
   if (!isRecord7(value)) return false;
-  return isOpaqueNSTypeInfo(value) && (value.name === "value" || isOpaqueCallableIdentifier(value.name)) && !opaqueTypeInfoContainsUnknown(value) && hasValidOpaqueParameterDefault(value);
+  return isOpaqueNSTypeInfo(value) && isOpaqueCallableArgumentIdentifier(value.name) && !opaqueTypeInfoContainsUnknown(value) && hasValidOpaqueParameterDefault(value);
 }
 function hasValidOpaqueParameterDefault(value) {
   const wrapper = value.defaultValue;
@@ -84665,7 +85315,8 @@ function assertOpaqueBaseClauseListValid(declaredConstructor, spec) {
         `Constructor "${declaredConstructor.id}" has a ${spec.entryLabel} that is not an object.`
       );
     }
-    if (!isOpaqueCallableIdentifier(entry.name)) {
+    const nameIsValid = spec.nameKind === "member" ? isOpaqueSchemaMemberIdentifier : isOpaqueCallableArgumentIdentifier;
+    if (!nameIsValid(entry.name)) {
       throw new Error(
         `Constructor "${declaredConstructor.id}" has a ${spec.entryLabel} with an invalid name.`
       );
@@ -84966,7 +85617,7 @@ function assertOpaqueMemberDefaultValueValid(member) {
 }
 function assertOpaqueNSFunctionValid(member, membersById) {
   if (member.kind !== 23) return;
-  if (!isOpaqueCallableIdentifier(member.name)) {
+  if (!isOpaqueCallableMemberIdentifier(member.name)) {
     throw new Error(`NSFunction "${member.id}" name is invalid.`);
   }
   if (member.storage !== void 0 && member.storage !== null) {
@@ -85102,34 +85753,14 @@ function assertOpaqueNSFunctionValid(member, membersById) {
     deferred: member.deferred
   });
 }
-var NEO_OBJECT_WORLD_KIND, READ_ONLY_SYNTHETIC_VALUE_ID_PREFIX2, OPAQUE_CALLABLE_IDENTIFIER_PATTERN, OPAQUE_CALLABLE_RESERVED_NAMES, REJECTED_OPAQUE_CONSTRUCTOR_KEYS, OPAQUE_INITIALIZER_KEYS, OPAQUE_BASE_ARGUMENTS_SPEC, OPAQUE_BASE_INITIALIZER_FIELDS_SPEC;
+var NEO_OBJECT_WORLD_KIND, READ_ONLY_SYNTHETIC_VALUE_ID_PREFIX2, REJECTED_OPAQUE_CONSTRUCTOR_KEYS, OPAQUE_INITIALIZER_KEYS, OPAQUE_BASE_ARGUMENTS_SPEC, OPAQUE_BASE_INITIALIZER_FIELDS_SPEC;
 var init_projectInterfaceValidation = __esm({
   "../convex/projectInterfaceValidation.ts"() {
     "use strict";
     init_projectVariantValidation();
+    init_src();
     NEO_OBJECT_WORLD_KIND = "object";
     READ_ONLY_SYNTHETIC_VALUE_ID_PREFIX2 = "__neo_readonly_default:";
-    OPAQUE_CALLABLE_IDENTIFIER_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
-    OPAQUE_CALLABLE_RESERVED_NAMES = /* @__PURE__ */ new Set([
-      "this",
-      "root",
-      "context",
-      "value",
-      "true",
-      "false",
-      "null",
-      "void",
-      "if",
-      "else",
-      "return",
-      "throw",
-      "var",
-      "int",
-      "float",
-      "decimal",
-      "string",
-      "bool"
-    ]);
     REJECTED_OPAQUE_CONSTRUCTOR_KEYS = [
       "bodyMode",
       "uiAction",
@@ -85140,6 +85771,7 @@ var init_projectInterfaceValidation = __esm({
     OPAQUE_BASE_ARGUMENTS_SPEC = {
       authoredKey: "baseArguments",
       compiledKey: "compiledBaseArguments",
+      nameKind: "parameter",
       entryLabel: "base argument",
       compiledLabel: "compiled base arguments",
       clauseLabel: "a base call"
@@ -85147,6 +85779,7 @@ var init_projectInterfaceValidation = __esm({
     OPAQUE_BASE_INITIALIZER_FIELDS_SPEC = {
       authoredKey: "baseInitializerFields",
       compiledKey: "compiledBaseInitializerFields",
+      nameKind: "member",
       entryLabel: "base initializer field",
       compiledLabel: "compiled base initializer fields",
       clauseLabel: "a base initializer block"
@@ -85158,34 +85791,37 @@ var init_projectInterfaceValidation = __esm({
 function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function assertIdentifier3(value, label) {
-  if (isValidSchemaAuthoredIdentifier(value)) return;
+function assertIdentifier(value, label, predicate) {
+  if (predicate(value)) return;
   throw new Error(
     `${label} must be a valid Neo/codegen identifier; use letters, digits, and underscores, begin with a letter or underscore, and avoid reserved language keywords.`
   );
 }
-function assertArgumentIdentifiers(value, ownerLabel) {
+function assertArgumentIdentifiers(value, ownerLabel, predicate) {
   if (!Array.isArray(value)) return;
   for (let index = 0; index < value.length; index += 1) {
     const argument2 = value[index];
     if (!isRecord8(argument2)) continue;
-    assertIdentifier3(
+    assertIdentifier(
       argument2.name,
-      `${ownerLabel} parameter ${index + 1} name ${JSON.stringify(argument2.name)}`
+      `${ownerLabel} parameter ${index + 1} name ${JSON.stringify(argument2.name)}`,
+      predicate
     );
   }
 }
 function assertClassIdentifiers(recordId, value) {
   if (!isRecord8(value)) return;
-  assertIdentifier3(
+  assertIdentifier(
     value.name,
-    `Class "${recordId}" name ${JSON.stringify(value.name)}`
+    `Class "${recordId}" name ${JSON.stringify(value.name)}`,
+    isValidSchemaAuthoredIdentifier
   );
   if (isRecord8(value.schema)) {
     for (const schemaKey of Object.keys(value.schema)) {
-      assertIdentifier3(
+      assertIdentifier(
         schemaKey,
-        `Class "${recordId}" schema key ${JSON.stringify(schemaKey)}`
+        `Class "${recordId}" schema key ${JSON.stringify(schemaKey)}`,
+        isValidSchemaMemberIdentifier
       );
     }
   }
@@ -85193,17 +85829,19 @@ function assertClassIdentifiers(recordId, value) {
   for (let index = 0; index < value.genericParams.length; index += 1) {
     const parameter4 = value.genericParams[index];
     if (!isRecord8(parameter4)) continue;
-    assertIdentifier3(
+    assertIdentifier(
       parameter4.name,
-      `Class "${recordId}" generic parameter ${index + 1} name ${JSON.stringify(parameter4.name)}`
+      `Class "${recordId}" generic parameter ${index + 1} name ${JSON.stringify(parameter4.name)}`,
+      isValidSchemaBindingIdentifier
     );
   }
 }
 function assertEnumIdentifiers(recordId, value) {
   if (!isRecord8(value)) return;
-  assertIdentifier3(
+  assertIdentifier(
     value.name,
-    `Enum "${recordId}" name ${JSON.stringify(value.name)}`
+    `Enum "${recordId}" name ${JSON.stringify(value.name)}`,
+    isValidSchemaAuthoredIdentifier
   );
   if (!isRecord8(value.options)) return;
   const optionIdsByFoldedName = /* @__PURE__ */ new Map();
@@ -85219,9 +85857,10 @@ function assertEnumIdentifiers(recordId, value) {
         `Enum "${recordId}" option "${optionId}" must embed the same stable id.`
       );
     }
-    assertIdentifier3(
+    assertIdentifier(
       option.name,
-      `Enum "${recordId}" option "${optionId}" name ${JSON.stringify(option.name)}`
+      `Enum "${recordId}" option "${optionId}" name ${JSON.stringify(option.name)}`,
+      isValidSchemaMemberIdentifier
     );
     const foldedName = option.name.toLowerCase();
     const collidingOptionId = optionIdsByFoldedName.get(foldedName);
@@ -85235,20 +85874,23 @@ function assertEnumIdentifiers(recordId, value) {
 }
 function assertInterfaceIdentifiers(recordId, value) {
   if (!isRecord8(value)) return;
-  assertIdentifier3(
+  assertIdentifier(
     value.name,
-    `Interface "${recordId}" name ${JSON.stringify(value.name)}`
+    `Interface "${recordId}" name ${JSON.stringify(value.name)}`,
+    isValidSchemaAuthoredIdentifier
   );
   if (!isRecord8(value.members)) return;
   for (const [memberKey, member] of Object.entries(value.members)) {
-    assertIdentifier3(
+    assertIdentifier(
       memberKey,
-      `Interface "${recordId}" member name ${JSON.stringify(memberKey)}`
+      `Interface "${recordId}" member name ${JSON.stringify(memberKey)}`,
+      isValidSchemaMemberIdentifier
     );
     if (!isRecord8(member) || member.kind !== "function") continue;
     assertArgumentIdentifiers(
       member.argumentTypes,
-      `Interface "${recordId}" function "${memberKey}"`
+      `Interface "${recordId}" function "${memberKey}"`,
+      isValidSchemaNSFunctionBindingIdentifier
     );
   }
 }
@@ -85260,15 +85902,17 @@ function isCallableOrPropertyMemberKind(value) {
 function assertMemberIdentifiers(recordId, value, directlyAuthoredMemberIds) {
   if (!isRecord8(value)) return;
   if (directlyAuthoredMemberIds.has(recordId) || isCallableOrPropertyMemberKind(value)) {
-    assertIdentifier3(
+    assertIdentifier(
       value.name,
-      `Member "${recordId}" name ${JSON.stringify(value.name)}`
+      `Member "${recordId}" name ${JSON.stringify(value.name)}`,
+      isValidSchemaMemberIdentifier
     );
   }
   if (value.kind !== 13 && value.kind !== 23) return;
   assertArgumentIdentifiers(
     value.argumentTypes,
-    `Function member "${recordId}"`
+    `Function member "${recordId}"`,
+    value.kind === 23 ? isValidSchemaNSFunctionBindingIdentifier : isValidSchemaBindingIdentifier
   );
 }
 function assertSchemaIdentifierWriteChangesValid(changes, directlyAuthoredMemberIds) {
@@ -112267,7 +112911,7 @@ var init_registry2 = __esm({
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
       formatVersion: 3,
       contractVersion: "3.13",
-      cliVersion: "0.32.3",
+      cliVersion: "0.33.0",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -118862,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.3");
+    console.log("0.33.0");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {