@neocompose/cli 0.70.3 → 0.70.5

package/dist/neo.mjs

@@ -8893,13 +8893,15 @@ var require_ignore = __commonJS({
     var EMPTY2 = "";
     var SPACE = " ";
     var ESCAPE = "\\";
-    var REGEX_TEST_BLANK_LINE = /^\s+$/;
+    var REGEX_LITERAL_SPECIAL = /[.*+?()[\]{}^$|\\/]/;
+    var BOM = "\uFEFF";
     var REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
     var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
     var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
     var REGEX_SPLITALL_CRLF = /\r?\n/g;
-    var REGEX_TEST_INVALID_PATH = /^\.{0,2}\/|^\.{1,2}$/;
-    var REGEX_TEST_TRAILING_SLASH = /\/$/;
+    var DOUBLE_SLASH = "//";
+    var SLASH_CODE = 47;
+    var DOT_CODE = 46;
     var SLASH = "/";
     var TMP_KEY_IGNORE = "node-ignore";
     if (typeof Symbol !== "undefined") {
@@ -8910,44 +8912,173 @@ var require_ignore = __commonJS({
       Object.defineProperty(object2, key, { value });
       return value;
     };
-    var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
     var RETURN_FALSE = () => false;
-    var sanitizeRange = (range2) => range2.replace(
-      REGEX_REGEXP_RANGE,
-      (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match : EMPTY2
-    );
-    var negateRange = (range2) => range2.startsWith("!") || range2.startsWith("\\^") ? `^${range2.slice(range2[0] === "!" ? 1 : 2)}` : range2;
     var cleanRangeBackSlash = (slashes) => {
       const { length } = slashes;
       return slashes.slice(0, length - length % 2);
     };
+    var POSIX_CLASSES = {
+      alnum: "0-9A-Za-z",
+      alpha: "A-Za-z",
+      blank: " \\t",
+      cntrl: "\\x00-\\x1f\\x7f",
+      digit: "0-9",
+      graph: "!-.0-~",
+      lower: "a-z",
+      print: " -.0-~",
+      punct: "!-.:-@\\[-`{-~",
+      // git's `sane-ctype.h` classifies \v and \f as control, not space,
+      //   unlike C's `isspace`
+      space: " \\t\\n\\r",
+      upper: "A-Z",
+      xdigit: "0-9A-Fa-f"
+    };
+    var CLASS_MEMBERS_TO_ESCAPE = "\\]^-[";
+    var escapeMember = (char) => CLASS_MEMBERS_TO_ESCAPE.indexOf(char) < 0 ? char : ESCAPE + char;
+    var NON_SLASH = "(?!\\/)";
+    var classSource = (negated, body) => {
+      if (negated) {
+        return `[^\\/${body}]`;
+      }
+      const source = `[${body}]`;
+      return new RegExp(source).test("/") ? NON_SLASH + source : source;
+    };
+    var scanBracket = (pattern, start) => {
+      const { length } = pattern;
+      let index = start + 1;
+      let negated = EMPTY2;
+      const lead = pattern[index];
+      if (lead === "!" || lead === "^") {
+        negated = "^";
+        index++;
+      }
+      let body = EMPTY2;
+      let prev = EMPTY2;
+      for (; ; ) {
+        const char = pattern[index];
+        if (char === UNDEFINED) {
+          return null;
+        }
+        if (char === ESCAPE) {
+          const escaped = pattern[index + 1];
+          if (escaped === UNDEFINED) {
+            return null;
+          }
+          body += escapeMember(escaped);
+          prev = escaped;
+          index++;
+        } else if (char === "-" && prev && index + 1 < length && pattern[index + 1] !== "]") {
+          index++;
+          let to = pattern[index];
+          if (to === ESCAPE) {
+            to = pattern[index += 1];
+          }
+          if (prev <= to) {
+            body += `-${escapeMember(to)}`;
+          }
+          prev = EMPTY2;
+        } else if (char === "[" && pattern[index + 1] === ":") {
+          const nameStart = index + 2;
+          let end = nameStart;
+          while (end < length && pattern[end] !== "]") {
+            end++;
+          }
+          if (end === length) {
+            return null;
+          }
+          if (end > nameStart && pattern[end - 1] === ":") {
+            const expanded = POSIX_CLASSES[pattern.slice(nameStart, end - 1)];
+            if (expanded === UNDEFINED) {
+              return null;
+            }
+            body += expanded;
+            prev = EMPTY2;
+            index = end;
+          } else {
+            body += escapeMember("[");
+            prev = "[";
+            index = nameStart - 2;
+          }
+        } else {
+          body += escapeMember(char);
+          prev = char;
+        }
+        index++;
+        if (pattern[index] === "]") {
+          return {
+            end: index,
+            source: classSource(negated, body)
+          };
+        }
+      }
+    };
+    var NEVER_MATCH = "[]";
+    var PLACEHOLDER = "\0";
+    var REGEX_RESTORE_PLACEHOLDER = new RegExp(
+      `${PLACEHOLDER}(\\d+)${PLACEHOLDER}`,
+      "g"
+    );
+    var TRAILING_WILDCARD = "\uE000";
+    var TRAILING_DOUBLESTAR = "\uE001";
+    var extractBrackets = (pattern) => {
+      const sources2 = [];
+      const hold = (source) => `${PLACEHOLDER}${sources2.push(source) - 1}${PLACEHOLDER}`;
+      const { length } = pattern;
+      let out = EMPTY2;
+      let index = 0;
+      while (index < length) {
+        const char = pattern[index];
+        if (char === ESCAPE) {
+          const escaped = pattern[index + 1];
+          if (escaped === UNDEFINED || escaped === SLASH && index + 2 === length) {
+            out += hold(NEVER_MATCH);
+          } else if (escaped === "*" || escaped === "[" || escaped === SPACE || escaped === ESCAPE) {
+            out += pattern.slice(index, index + 2);
+          } else {
+            out += hold(
+              REGEX_LITERAL_SPECIAL.test(escaped) ? ESCAPE + escaped : escaped
+            );
+          }
+          index += 2;
+        } else if (char === PLACEHOLDER) {
+          out += hold(`[${PLACEHOLDER}]`);
+          index++;
+        } else if (char === "[") {
+          const scanned = scanBracket(pattern, index);
+          if (scanned === null) {
+            out += hold(NEVER_MATCH);
+            index = length;
+          } else {
+            out += hold(scanned.source);
+            index = scanned.end + 1;
+          }
+        } else {
+          out += char;
+          index++;
+        }
+      }
+      return {
+        source: out,
+        sources: sources2
+      };
+    };
+    var DIRECT = null;
+    var REGEX_INNER_SLASH = /\/(?!$)/;
     var REPLACERS = [
-      [
-        // Remove BOM
-        // TODO:
-        // Other similar zero-width characters?
-        /^\uFEFF/,
-        () => EMPTY2
-      ],
-      // > Trailing spaces are ignored unless they are quoted with backslash ("\")
-      [
-        // (a\ ) -> (a )
-        // (a  ) -> (a)
-        // (a ) -> (a)
-        // (a \ ) -> (a  )
-        /((?:\\\\)*?)(\\?\s+)$/,
-        (_, m1, m2) => m1 + (m2.indexOf("\\") === 0 ? SPACE : EMPTY2)
-      ],
       // Replace (\ ) with ' '
+      // Only a space: an escaped tab or other whitespace is already a literal by
+      //   the time it reaches here, and a bare tab must be left as one, not turned
+      //   into a space.
       // (\ ) -> ' '
       // (\\ ) -> '\\ '
       // (\\\ ) -> '\\ '
       [
-        /(\\+?)\s/g,
-        (_, m1) => {
-          const { length } = m1;
-          return m1.slice(0, length - length % 2) + SPACE;
-        }
+        // A run of backslashes is taken whole, from its first one, so no match
+        //   ever starts again inside it -- `(\\+?) ` did, which made a long run
+        //   quadratic.
+        /(\\+)( ?)/g,
+        (_, run, space) => space ? run.slice(0, run.length - run.length % 2) + SPACE : run,
+        ESCAPE + SPACE
       ],
       // Escape metacharacters
       // which is written down by users but means special for regular expressions.
@@ -8972,7 +9103,8 @@ var require_ignore = __commonJS({
       [
         // > a question mark (?) matches a single character
         /(?!\\)\?/g,
-        () => "[^/]"
+        () => "[^/]",
+        "?"
       ],
       // leading slash
       [
@@ -8980,12 +9112,14 @@ var require_ignore = __commonJS({
         // > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c".
         // A leading slash matches the beginning of the pathname
         /^\//,
-        () => "^"
+        () => "^",
+        SLASH
       ],
       // replace special metacharacter slash after the leading slash
       [
         /\//g,
-        () => "\\/"
+        () => "\\/",
+        SLASH
       ],
       [
         // > A leading "**" followed by a slash means match in all directories.
@@ -8996,16 +9130,21 @@ var require_ignore = __commonJS({
         // Notice that the '*'s have been replaced as '\\*'
         /^\^*(?:\\\*\\\*\\\/)+/,
         // '**/foo' <-> 'foo'
-        () => "^(?:.*\\/)?"
+        () => "^(?:.*\\/)?",
+        "*"
       ],
       // starting
       [
         // there will be no leading '/'
         //   (which has been replaced by section "leading slash")
         // If starts with '**', adding a '^' to the regular expression also works
-        /^(?=[^^])/,
-        function startingReplacer() {
-          return !/\/(?!$)/.test(this) ? "(?:^|\\/)" : "^";
+        DIRECT,
+        (source, pattern) => {
+          if (!source || source[0] === "^") {
+            return source;
+          }
+          const anchor = !REGEX_INNER_SLASH.test(pattern) ? "(?:^|\\/)" : "^";
+          return anchor + source;
         }
       ],
       // two globstars
@@ -9015,7 +9154,8 @@ var require_ignore = __commonJS({
         // Zero, one or several directories
         // should not use '*', or it will be replaced by the next replacer
         // Check if it is not the last `'/**'`
-        (_, index, str) => index + 6 < str.length ? "(?:\\/[^\\/]+)*" : "\\/.+"
+        (_, index, str) => index + 6 < str.length ? str.slice(index + 6) === "\\/" ? "(?:\\/[^\\/]+)+" : "(?:\\/[^\\/]+)*" : `\\/${TRAILING_DOUBLESTAR}`,
+        "*"
       ],
       // normal intermediate wildcards
       [
@@ -9030,32 +9170,56 @@ var require_ignore = __commonJS({
         (_, p1, p2) => {
           const unescaped = p2.replace(/\\\*/g, "[^\\/]*");
           return p1 + unescaped;
-        }
+        },
+        "*"
+      ],
+      // trailing wildcard, held apart from a literal star
+      [
+        // The step above leaves a trailing `*` alone, so a single `\*` is all that
+        //   can be left at the end here. Whether it is a wildcard or a literal
+        //   turns on the backslashes the user put in front of it: the escaper has
+        //   since doubled every one, so what stands here is those `2N` doubled
+        //   backslashes and then the star's own escape. An even number of the
+        //   original `N` leaves the star unescaped -- a wildcard -- and an odd
+        //   number escapes it -- a literal. This runs while the two are still
+        //   distinct, before the unescape steps below collapse the literal onto
+        //   the very `\*` a wildcard leaves behind.
+        /(^|[^\\])((?:\\\\)*)\\\*$/,
+        (match, p1, p2) => (
+          // `p2` holds the doubled user backslashes; half of them is `N`.
+          p2.length / 2 % 2 === 0 ? p1 + p2 + TRAILING_WILDCARD : match
+        ),
+        "*"
       ],
       [
         // unescape, revert step 3 except for back slash
         // For example, if a user escape a '\\*',
         // after step 3, the result will be '\\\\\\*'
         /\\\\\\(?=[$.|*+(){^])/g,
-        () => ESCAPE
+        () => ESCAPE,
+        ESCAPE + ESCAPE
       ],
       [
         // '\\\\' -> '\\'
         /\\\\/g,
-        () => ESCAPE
+        () => ESCAPE,
+        ESCAPE + ESCAPE
       ],
       [
-        // > The range notation, e.g. [a-zA-Z],
-        // > can be used to match one of the characters in a range.
+        // Every real bracket expression -- POSIX classes included -- has already
+        //   been held aside by `extractBrackets`, so the only `[` left in the
+        //   pattern is an escaped, literal one.
         // `\` is escaped by step 3
-        /(\\)?\[([^\]/]*?)(\\*)($|\])/g,
-        (match, leadEscape, range2, endEscape, close) => leadEscape === ESCAPE ? `\\[${range2}${cleanRangeBackSlash(endEscape)}${close}` : close === "]" ? endEscape.length % 2 === 0 ? `[${negateRange(sanitizeRange(range2))}${endEscape}]` : "[]" : "[]"
+        /\\\[([^\]/]*?)(\\*)($|\])/g,
+        // '\\[bar]' -> '\\\\[bar\\]'
+        (match, range2, endEscape, close) => `\\[${range2}${cleanRangeBackSlash(endEscape)}${close}`,
+        "["
       ],
       // ending
       [
         // 'js' will not match 'js.'
         // 'ab' will not match 'abc'
-        /(?:[^*])$/,
+        DIRECT,
         // WTF!
         // https://git-scm.com/docs/gitignore
         // changes in [2.22.1](https://git-scm.com/docs/gitignore/2.22.1)
@@ -9066,29 +9230,175 @@ var require_ignore = __commonJS({
         // 'js*' will not match 'a.js'
         // 'js/' will not match 'a.js'
         // 'js' will match 'a.js' and 'a.js/'
-        (match) => /\/$/.test(match) ? `${match}$` : `${match}(?=$|\\/$)`
+        (source) => {
+          const last = source[source.length - 1];
+          if (!last || last === TRAILING_WILDCARD || last === TRAILING_DOUBLESTAR) {
+            return source;
+          }
+          return last === SLASH ? `${source}$` : `${source}(?=$|\\/$)`;
+        }
       ]
     ];
-    var REGEX_REPLACE_TRAILING_WILDCARD = /(^|\\\/)?\\\*$/;
+    var REGEX_REPLACE_TRAILING_WILDCARD = /(^|\\\/)?\uE000$/;
     var MODE_IGNORE = "regex";
     var MODE_CHECK_IGNORE = "checkRegex";
     var UNDERSCORE = "_";
-    var TRAILING_WILD_CARD_REPLACERS = {
-      [MODE_IGNORE](_, p1) {
-        const prefix = p1 ? `${p1}[^/]+` : "[^/]*";
-        return `${prefix}(?=$|\\/$)`;
-      },
-      [MODE_CHECK_IGNORE](_, p1) {
-        const prefix = p1 ? `${p1}[^/]*` : "[^/]*";
-        return `${prefix}(?=$|\\/$)`;
+    var replaceTrailingWildcard = (_, p1) => {
+      const prefix = p1 ? `${p1}[^/]+` : "[^/]*";
+      return `${prefix}(?=$|\\/$)`;
+    };
+    var REGEX_REPLACE_TRAILING_DOUBLESTAR = /\uE001$/;
+    var replaceTrailingDoublestar = () => ".+(?=$|\\/$)";
+    var WILDCARD = "[^\\/]*";
+    var separatorAfter = (run, at3) => {
+      let separator = EMPTY2;
+      for (let index = at3 + 1; index < run.length && !run[index].wildcard; index++) {
+        separator += run[index].single;
+      }
+      return separator;
+    };
+    var pinWildcards = (source) => {
+      if (source.indexOf(WILDCARD) < 0) {
+        return source;
+      }
+      const tokens = [];
+      const { length } = source;
+      let index = 0;
+      while (index < length) {
+        const char = source[index];
+        if (source.startsWith(WILDCARD, index)) {
+          tokens.push({ wildcard: true });
+          index += WILDCARD.length;
+        } else if (char === "[") {
+          let end = index + 1;
+          if (source[end] === "^") {
+            end++;
+          }
+          if (source[end] === "]") {
+            end++;
+          }
+          while (end < length && source[end] !== "]") {
+            end += source[end] === ESCAPE ? 2 : 1;
+          }
+          end++;
+          tokens.push({ single: source.slice(index, end) });
+          index = end;
+        } else if (char === ESCAPE) {
+          tokens.push({ single: source.slice(index, index + 2) });
+          index += 2;
+        } else if (char === "(") {
+          let depth = 0;
+          let end = index;
+          do {
+            if (source[end] === ESCAPE) {
+              end++;
+            } else if (source[end] === "(") {
+              depth++;
+            } else if (source[end] === ")") {
+              depth--;
+            }
+            end++;
+          } while (end < length && depth > 0);
+          if ("*+?".indexOf(source[end]) >= 0) {
+            end++;
+          }
+          tokens.push({ boundary: source.slice(index, end) });
+          index = end;
+        } else if (char === "^" || char === "$") {
+          tokens.push({ boundary: char });
+          index++;
+        } else {
+          tokens.push({ single: char });
+          index++;
+        }
       }
+      let out = EMPTY2;
+      let run = [];
+      const flush = () => {
+        let lastWildcard;
+        run.forEach((token, at3) => {
+          if (token.wildcard) {
+            lastWildcard = at3;
+          }
+        });
+        run.forEach((token, at3) => {
+          if (!token.wildcard) {
+            out += token.single;
+            return;
+          }
+          out += at3 === lastWildcard ? WILDCARD : `(?:(?!${separatorAfter(run, at3)})[^\\/])*`;
+        });
+        run = [];
+      };
+      tokens.forEach((token) => {
+        if (token.boundary === void 0) {
+          run.push(token);
+          return;
+        }
+        flush();
+        out += token.boundary;
+      });
+      flush();
+      return out;
+    };
+    var makeRegexPrefix = (pattern) => {
+      const { source, sources: sources2 } = extractBrackets(pattern);
+      const replaced = REPLACERS.reduce(
+        // A pass whose matcher finds nothing hands back the very string it was
+        //   given, so asking first costs a search and saves a rewrite. Ten of the
+        //   fifteen passes never fire for a typical .gitignore line, and between
+        //   them they were 45% of this chain.
+        (prev, [matcher, replacer, required2]) => {
+          if (matcher === DIRECT) {
+            return replacer(prev, pattern);
+          }
+          if (required2 !== UNDEFINED && prev.indexOf(required2) < 0) {
+            return prev;
+          }
+          return matcher.test(prev) ? prev.replace(matcher, replacer.bind(pattern)) : prev;
+        },
+        source
+      );
+      return sources2.length ? replaced.replace(
+        REGEX_RESTORE_PLACEHOLDER,
+        (match, index) => sources2[index]
+      ) : replaced;
+    };
+    var checkSourceOf = (body, prefix) => {
+      if (body[body.length - 1] === SLASH) {
+        prefix = makeRegexPrefix(body.slice(0, -1));
+      }
+      const head = prefix.slice(0, -1);
+      const last = prefix[prefix.length - 1];
+      return last === TRAILING_WILDCARD ? `${head}$` : last === TRAILING_DOUBLESTAR ? `${head}.*$` : NEVER_MATCH;
+    };
+    var matchesBasename = (body) => {
+      const index = body.indexOf(SLASH);
+      return index < 0 || index === body.length - 1;
+    };
+    var basenameOf = (path) => {
+      const end = path.length - 1;
+      const index = path.lastIndexOf(
+        SLASH,
+        path[end] === SLASH ? end - 1 : end
+      );
+      return index < 0 ? path : path.slice(index + 1);
+    };
+    var parentOf = (path) => {
+      if (path.charCodeAt(0) === SLASH_CODE || path.indexOf(DOUBLE_SLASH) >= 0) {
+        const slices = path.split(SLASH).filter(Boolean);
+        slices.pop();
+        return slices.length ? slices.join(SLASH) + SLASH : EMPTY2;
+      }
+      const end = path.length - 1;
+      const cut = path.lastIndexOf(
+        SLASH,
+        path.charCodeAt(end) === SLASH_CODE ? end - 1 : end
+      );
+      return cut < 0 ? EMPTY2 : path.slice(0, cut + 1);
     };
-    var makeRegexPrefix = (pattern) => REPLACERS.reduce(
-      (prev, [matcher, replacer]) => prev.replace(matcher, replacer.bind(pattern)),
-      pattern
-    );
     var isString2 = (subject) => typeof subject === "string";
-    var checkPattern = (pattern) => pattern && isString2(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0;
+    var checkPattern = (pattern) => pattern && isString2(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern);
     var splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF).filter(Boolean);
     var IgnoreRule = class {
       constructor(pattern, mark, body, ignoreCase, negative, prefix) {
@@ -9099,6 +9409,14 @@ var require_ignore = __commonJS({
         define(this, "ignoreCase", ignoreCase);
         define(this, "regexPrefix", prefix);
       }
+      // Worked out on first use and kept behind an own property, the way `regex`
+      //   caches itself in `_regex`. Deciding it in the constructor instead would
+      //   add a fourth `defineProperty` to every rule ever built, which cost 4% of
+      //   every compile -- including the compiles of rules that are never matched
+      //   against anything.
+      get _basenameOnly() {
+        return define(this, "_basenameOnly", matchesBasename(this.body));
+      }
       get regex() {
         const key = UNDERSCORE + MODE_IGNORE;
         if (this[key]) {
@@ -9114,24 +9432,51 @@ var require_ignore = __commonJS({
         return this._make(MODE_CHECK_IGNORE, key);
       }
       _make(mode, key) {
-        const str = this.regexPrefix.replace(
-          REGEX_REPLACE_TRAILING_WILDCARD,
-          // It does not need to bind pattern
-          TRAILING_WILD_CARD_REPLACERS[mode]
+        const str = pinWildcards(
+          mode === MODE_IGNORE ? this.regexPrefix.replace(REGEX_REPLACE_TRAILING_WILDCARD, replaceTrailingWildcard).replace(REGEX_REPLACE_TRAILING_DOUBLESTAR, replaceTrailingDoublestar) : checkSourceOf(this.body, this.regexPrefix)
         );
         const regex = this.ignoreCase ? new RegExp(str, "i") : new RegExp(str);
         return define(this, key, regex);
       }
     };
+    var isLineEnd = (char) => char === "\r" || char === "\n";
+    var trimEnd4 = (body) => {
+      let end = body.length;
+      while (end && isLineEnd(body[end - 1])) {
+        end--;
+      }
+      const lineEnd = end;
+      while (end && body[end - 1] === SPACE) {
+        end--;
+      }
+      if (end === lineEnd) {
+        return body.slice(0, end);
+      }
+      let backslashes = 0;
+      while (backslashes < end && body[end - backslashes - 1] === ESCAPE) {
+        backslashes++;
+      }
+      return backslashes % 2 ? body.slice(0, end - 1) + SPACE : body.slice(0, end);
+    };
     var createRule = ({
       pattern,
       mark
     }, ignoreCase) => {
+      let body = pattern[0] === BOM ? pattern.slice(1) : pattern;
+      if (body[0] === "#") {
+        return;
+      }
       let negative = false;
-      let body = pattern;
-      if (body.indexOf("!") === 0) {
+      if (body[0] === "!") {
         negative = true;
-        body = body.substr(1);
+        body = body.slice(1);
+      }
+      const last = body[body.length - 1];
+      if (last === SPACE || last === "\r" || last === "\n") {
+        body = trimEnd4(body);
+      }
+      if (!body) {
+        return;
       }
       body = body.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
       const regexPrefix = makeRegexPrefix(body);
@@ -9148,10 +9493,12 @@ var require_ignore = __commonJS({
       constructor(ignoreCase) {
         this._ignoreCase = ignoreCase;
         this._rules = [];
+        this._basenameCount = 0;
       }
       _add(pattern) {
         if (pattern && pattern[KEY_IGNORE]) {
           this._rules = this._rules.concat(pattern._rules._rules);
+          this._basenameCount += pattern._rules._basenameCount;
           this._added = true;
           return;
         }
@@ -9160,10 +9507,13 @@ var require_ignore = __commonJS({
             pattern
           };
         }
-        if (checkPattern(pattern.pattern)) {
-          const rule = createRule(pattern, this._ignoreCase);
+        const rule = checkPattern(pattern.pattern) && createRule(pattern, this._ignoreCase);
+        if (rule) {
           this._added = true;
           this._rules.push(rule);
+          if (matchesBasename(rule.body)) {
+            this._basenameCount++;
+          }
         }
       }
       // @param {Array<string> | string | Ignore} pattern
@@ -9172,8 +9522,39 @@ var require_ignore = __commonJS({
         makeArray(
           isString2(pattern) ? splitPattern(pattern) : pattern
         ).forEach(this._add, this);
+        if (this._added) {
+          this._literalRules = UNDEFINED;
+        }
         return this._added;
       }
+      // Match the literal 'abc/' for `checkIgnore`, last rule wins. Only a rule
+      //   ending in a wildcard can match it (see `checkSourceOf`), so the rest
+      //   are left out once, rather than tested or compiled for every path.
+      testLiteral(path) {
+        const rules = this._literalRules || (this._literalRules = this._rules.filter(
+          ({ body }) => body[body.length - (body[body.length - 1] === SLASH ? 2 : 1)] === "*"
+        ));
+        let ignored = false;
+        let unignored = false;
+        let matchedRule;
+        for (let index = rules.length - 1; index >= 0; index--) {
+          const rule = rules[index];
+          if (rule.checkRegex.test(path)) {
+            ignored = !rule.negative;
+            unignored = rule.negative;
+            matchedRule = rule.negative ? UNDEFINED : rule;
+            break;
+          }
+        }
+        const ret = {
+          ignored,
+          unignored
+        };
+        if (matchedRule) {
+          ret.rule = matchedRule;
+        }
+        return ret;
+      }
       // Test one single path without recursively checking parent directories
       //
       // - checkUnignored `boolean` whether should check if the path is unignored,
@@ -9185,19 +9566,22 @@ var require_ignore = __commonJS({
         let ignored = false;
         let unignored = false;
         let matchedRule;
-        this._rules.forEach((rule) => {
+        const rules = this._rules;
+        const { length } = rules;
+        const shortcut = this._basenameCount * 2 >= length;
+        const basename5 = shortcut ? basenameOf(path) : path;
+        for (let index = 0; index < length; index++) {
+          const rule = rules[index];
           const { negative } = rule;
-          if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
-            return;
-          }
-          const matched = rule[mode].test(path);
-          if (!matched) {
-            return;
+          const skip = unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored;
+          if (!skip && rule[mode].test(
+            shortcut && rule._basenameOnly ? basename5 : path
+          )) {
+            ignored = !negative;
+            unignored = negative;
+            matchedRule = negative ? UNDEFINED : rule;
           }
-          ignored = !negative;
-          unignored = negative;
-          matchedRule = negative ? UNDEFINED : rule;
-        });
+        }
         const ret = {
           ignored,
           unignored
@@ -9230,7 +9614,26 @@ var require_ignore = __commonJS({
       }
       return true;
     };
-    var isNotRelative = (path) => REGEX_TEST_INVALID_PATH.test(path);
+    var isNotRelative = (path) => {
+      const first = path.charCodeAt(0);
+      if (first === SLASH_CODE) {
+        return true;
+      }
+      if (first !== DOT_CODE) {
+        return false;
+      }
+      if (path.length === 1) {
+        return true;
+      }
+      const second = path.charCodeAt(1);
+      if (second === SLASH_CODE) {
+        return true;
+      }
+      if (second !== DOT_CODE) {
+        return false;
+      }
+      return path.length === 2 || path.charCodeAt(2) === SLASH_CODE;
+    };
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p) => p;
     var Ignore = class {
@@ -9259,52 +9662,33 @@ var require_ignore = __commonJS({
         return this.add(pattern);
       }
       // @returns {TestResult}
-      _test(originalPath, cache, checkUnignored, slices) {
+      _test(originalPath, cache, checkUnignored) {
         const path = originalPath && checkPath.convert(originalPath);
         checkPath(
           path,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path, cache, checkUnignored, slices);
+        return this._t(path, cache, checkUnignored);
       }
       checkIgnore(path) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path)) {
+        if (path.charCodeAt(path.length - 1) !== SLASH_CODE) {
           return this.test(path);
         }
-        const slices = path.split(SLASH).filter(Boolean);
-        slices.pop();
-        if (slices.length) {
-          const parent = this._t(
-            slices.join(SLASH) + SLASH,
-            this._testCache,
-            true,
-            slices
-          );
-          if (parent.ignored) {
-            return parent;
-          }
+        const dir = this._t(path, this._testCache, true);
+        if (dir.ignored) {
+          return dir;
         }
-        return this._rules.test(path, false, MODE_CHECK_IGNORE);
+        const literal3 = this._rules.testLiteral(path);
+        return literal3.ignored || literal3.unignored ? literal3 : dir;
       }
-      _t(path, cache, checkUnignored, slices) {
+      _t(path, cache, checkUnignored) {
         if (path in cache) {
           return cache[path];
         }
-        if (!slices) {
-          slices = path.split(SLASH).filter(Boolean);
-        }
-        slices.pop();
-        if (!slices.length) {
-          return cache[path] = this._rules.test(path, checkUnignored, MODE_IGNORE);
-        }
-        const parent = this._t(
-          slices.join(SLASH) + SLASH,
-          cache,
-          checkUnignored,
-          slices
-        );
-        return cache[path] = parent.ignored ? parent : this._rules.test(path, checkUnignored, MODE_IGNORE);
+        const parentPath = parentOf(path);
+        const parent = parentPath ? this._t(parentPath, cache, checkUnignored) : UNDEFINED;
+        return cache[path] = parent && parent.ignored ? parent : this._rules.test(path, checkUnignored, MODE_IGNORE);
       }
       ignores(path) {
         return this._test(path, this._ignoreCache, false).ignored;
@@ -31614,16 +31998,12 @@ function assertEnum(value, path) {
 }
 function assertGlobal(value, path) {
   const global = record(value, path);
-  exactKeys(global, path, [
-    "id",
-    "state",
-    "source",
-    "name",
-    "type",
-    "annotations",
-    "initializer",
-    "initializerSource"
-  ]);
+  exactKeysWithOptional(
+    global,
+    path,
+    ["id", "state", "source", "name", "type", "annotations", "initializer"],
+    ["initializerSource"]
+  );
   assertIdentity(global, path);
   if (global.initializerSource !== void 0)
     assertLocation(global.initializerSource, `${path}.initializerSource`);
@@ -31937,7 +32317,7 @@ var init_registry = __esm({
   "../packages/manifest/schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.70.3",
+      cliVersion: "0.70.5",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -34972,19 +35352,8 @@ function _addIssue(context, label, dataset, config$1, other) {
   else dataset.issues = [issue];
 }
 // @__NO_SIDE_EFFECTS__
-function _getStandardProps(context) {
-  let cached = _standardCache.get(context);
-  if (!cached) {
-    cached = {
-      version: 1,
-      vendor: "valibot",
-      validate(value$1) {
-        return context["~run"]({ value: value$1 }, /* @__PURE__ */ getGlobalConfig());
-      }
-    };
-    _standardCache.set(context, cached);
-  }
-  return cached;
+function _isSameValueZero(value1, value2) {
+  return value1 === value2 || Number.isNaN(value1) && Number.isNaN(value2);
 }
 // @__NO_SIDE_EFFECTS__
 function _isValidObjectKey(object$1, key) {
@@ -34996,6 +35365,14 @@ function _joinExpects(values$1, separator) {
   if (list.length > 1) return `(${list.join(` ${separator} `)})`;
   return list[0] ?? "never";
 }
+function _standardSchema(schema) {
+  schema["~standard"] = {
+    version: 1,
+    vendor: "valibot",
+    validate: (value$1) => schema["~run"]({ value: value$1 }, /* @__PURE__ */ getGlobalConfig())
+  };
+  return schema;
+}
 // @__NO_SIDE_EFFECTS__
 function check(requirement, message$1) {
   return {
@@ -35181,7 +35558,7 @@ function getDefault(schema, dataset, config$1) {
 }
 // @__NO_SIDE_EFFECTS__
 function array2(item, message$1) {
-  return {
+  return _standardSchema({
     kind: "schema",
     type: "array",
     reference: array2,
@@ -35189,9 +35566,6 @@ function array2(item, message$1) {
     async: false,
     item,
     message: message$1,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
     "~run"(dataset, config$1) {
       const input = dataset.value;
       if (Array.isArray(input)) {
@@ -35225,30 +35599,27 @@ function array2(item, message$1) {
       } else _addIssue(this, "type", dataset, config$1);
       return dataset;
     }
-  };
+  });
 }
 // @__NO_SIDE_EFFECTS__
 function boolean(message$1) {
-  return {
+  return _standardSchema({
     kind: "schema",
     type: "boolean",
     reference: boolean,
     expects: "boolean",
     async: false,
     message: message$1,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
     "~run"(dataset, config$1) {
       if (typeof dataset.value === "boolean") dataset.typed = true;
       else _addIssue(this, "type", dataset, config$1);
       return dataset;
     }
-  };
+  });
 }
 // @__NO_SIDE_EFFECTS__
 function custom(check$1, message$1) {
-  return {
+  return _standardSchema({
     kind: "schema",
     type: "custom",
     reference: custom,
@@ -35256,19 +35627,16 @@ function custom(check$1, message$1) {
     async: false,
     check: check$1,
     message: message$1,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
     "~run"(dataset, config$1) {
       if (this.check(dataset.value)) dataset.typed = true;
       else _addIssue(this, "type", dataset, config$1);
       return dataset;
     }
-  };
+  });
 }
 // @__NO_SIDE_EFFECTS__
 function exactOptional(wrapped, default_) {
-  return {
+  return _standardSchema({
     kind: "schema",
     type: "exact_optional",
     reference: exactOptional,
@@ -35276,34 +35644,28 @@ function exactOptional(wrapped, default_) {
     async: false,
     wrapped,
     default: default_,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
     "~run"(dataset, config$1) {
       return this.wrapped["~run"](dataset, config$1);
     }
-  };
+  });
 }
 // @__NO_SIDE_EFFECTS__
 function lazy(getter) {
-  return {
+  return _standardSchema({
     kind: "schema",
     type: "lazy",
     reference: lazy,
     expects: "unknown",
     async: false,
     getter,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
     "~run"(dataset, config$1) {
       return this.getter(dataset.value)["~run"](dataset, config$1);
     }
-  };
+  });
 }
 // @__NO_SIDE_EFFECTS__
 function literal2(literal_, message$1) {
-  return {
+  return _standardSchema({
     kind: "schema",
     type: "literal",
     reference: literal2,
@@ -35311,37 +35673,31 @@ function literal2(literal_, message$1) {
     async: false,
     literal: literal_,
     message: message$1,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
     "~run"(dataset, config$1) {
-      if (dataset.value === this.literal) dataset.typed = true;
+      if (/* @__PURE__ */ _isSameValueZero(dataset.value, this.literal)) dataset.typed = true;
       else _addIssue(this, "type", dataset, config$1);
       return dataset;
     }
-  };
+  });
 }
 // @__NO_SIDE_EFFECTS__
 function never(message$1) {
-  return {
+  return _standardSchema({
     kind: "schema",
     type: "never",
     reference: never,
     expects: "never",
     async: false,
     message: message$1,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
     "~run"(dataset, config$1) {
       _addIssue(this, "type", dataset, config$1);
       return dataset;
     }
-  };
+  });
 }
 // @__NO_SIDE_EFFECTS__
 function nullable(wrapped, default_) {
-  return {
+  return _standardSchema({
     kind: "schema",
     type: "nullable",
     reference: nullable,
@@ -35349,9 +35705,6 @@ function nullable(wrapped, default_) {
     async: false,
     wrapped,
     default: default_,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
     "~run"(dataset, config$1) {
       if (dataset.value === null) {
         if (this.default !== void 0) dataset.value = /* @__PURE__ */ getDefault(this, dataset, config$1);
@@ -35362,30 +35715,27 @@ function nullable(wrapped, default_) {
       }
       return this.wrapped["~run"](dataset, config$1);
     }
-  };
+  });
 }
 // @__NO_SIDE_EFFECTS__
 function number(message$1) {
-  return {
+  return _standardSchema({
     kind: "schema",
     type: "number",
     reference: number,
     expects: "number",
     async: false,
     message: message$1,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
     "~run"(dataset, config$1) {
       if (typeof dataset.value === "number" && !isNaN(dataset.value)) dataset.typed = true;
       else _addIssue(this, "type", dataset, config$1);
       return dataset;
     }
-  };
+  });
 }
 // @__NO_SIDE_EFFECTS__
 function optional(wrapped, default_) {
-  return {
+  return _standardSchema({
     kind: "schema",
     type: "optional",
     reference: optional,
@@ -35393,9 +35743,6 @@ function optional(wrapped, default_) {
     async: false,
     wrapped,
     default: default_,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
     "~run"(dataset, config$1) {
       if (dataset.value === void 0) {
         if (this.default !== void 0) dataset.value = /* @__PURE__ */ getDefault(this, dataset, config$1);
@@ -35406,11 +35753,11 @@ function optional(wrapped, default_) {
       }
       return this.wrapped["~run"](dataset, config$1);
     }
-  };
+  });
 }
 // @__NO_SIDE_EFFECTS__
 function picklist(options, message$1) {
-  return {
+  return _standardSchema({
     kind: "schema",
     type: "picklist",
     reference: picklist,
@@ -35418,19 +35765,16 @@ function picklist(options, message$1) {
     async: false,
     options,
     message: message$1,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
     "~run"(dataset, config$1) {
       if (this.options.includes(dataset.value)) dataset.typed = true;
       else _addIssue(this, "type", dataset, config$1);
       return dataset;
     }
-  };
+  });
 }
 // @__NO_SIDE_EFFECTS__
 function record2(key, value$1, message$1) {
-  return {
+  return _standardSchema({
     kind: "schema",
     type: "record",
     reference: record2,
@@ -35439,9 +35783,6 @@ function record2(key, value$1, message$1) {
     key,
     value: value$1,
     message: message$1,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
     "~run"(dataset, config$1) {
       const input = dataset.value;
       if (input && typeof input === "object") {
@@ -35494,11 +35835,11 @@ function record2(key, value$1, message$1) {
       } else _addIssue(this, "type", dataset, config$1);
       return dataset;
     }
-  };
+  });
 }
 // @__NO_SIDE_EFFECTS__
 function strictObject(entries$1, message$1) {
-  return {
+  return _standardSchema({
     kind: "schema",
     type: "strict_object",
     reference: strictObject,
@@ -35506,9 +35847,6 @@ function strictObject(entries$1, message$1) {
     async: false,
     entries: entries$1,
     message: message$1,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
     "~run"(dataset, config$1) {
       const input = dataset.value;
       if (input && typeof input === "object") {
@@ -35557,7 +35895,7 @@ function strictObject(entries$1, message$1) {
           }
         }
         if (!dataset.issues || !config$1.abortEarly) {
-          for (const key in input) if (!(key in this.entries)) {
+          for (const key in input) if (!Object.prototype.hasOwnProperty.call(this.entries, key)) {
             _addIssue(this, "key", dataset, config$1, {
               input: key,
               expected: "never",
@@ -35575,26 +35913,23 @@ function strictObject(entries$1, message$1) {
       } else _addIssue(this, "type", dataset, config$1);
       return dataset;
     }
-  };
+  });
 }
 // @__NO_SIDE_EFFECTS__
 function string2(message$1) {
-  return {
+  return _standardSchema({
     kind: "schema",
     type: "string",
     reference: string2,
     expects: "string",
     async: false,
     message: message$1,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
     "~run"(dataset, config$1) {
       if (typeof dataset.value === "string") dataset.typed = true;
       else _addIssue(this, "type", dataset, config$1);
       return dataset;
     }
-  };
+  });
 }
 // @__NO_SIDE_EFFECTS__
 function _subIssues(datasets) {
@@ -35605,7 +35940,7 @@ function _subIssues(datasets) {
 }
 // @__NO_SIDE_EFFECTS__
 function union(options, message$1) {
-  return {
+  return _standardSchema({
     kind: "schema",
     type: "union",
     reference: union,
@@ -35613,9 +35948,6 @@ function union(options, message$1) {
     async: false,
     options,
     message: message$1,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
     "~run"(dataset, config$1) {
       let validDataset;
       let typedDatasets;
@@ -35640,11 +35972,11 @@ function union(options, message$1) {
       else _addIssue(this, "type", dataset, config$1, { issues: /* @__PURE__ */ _subIssues(untypedDatasets) });
       return dataset;
     }
-  };
+  });
 }
 // @__NO_SIDE_EFFECTS__
 function variant(key, options, message$1) {
-  return {
+  return _standardSchema({
     kind: "schema",
     type: "variant",
     reference: variant,
@@ -35653,9 +35985,6 @@ function variant(key, options, message$1) {
     key,
     options,
     message: message$1,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
     "~run"(dataset, config$1) {
       const input = dataset.value;
       if (input && typeof input === "object") {
@@ -35710,7 +36039,7 @@ function variant(key, options, message$1) {
       } else _addIssue(this, "type", dataset, config$1);
       return dataset;
     }
-  };
+  });
 }
 function parse(schema, input, config$1) {
   const dataset = schema["~run"]({ value: input }, /* @__PURE__ */ getGlobalConfig(config$1));
@@ -35719,12 +36048,9 @@ function parse(schema, input, config$1) {
 }
 // @__NO_SIDE_EFFECTS__
 function pipe(...pipe$1) {
-  return {
+  return _standardSchema({
     ...pipe$1[0],
     pipe: pipe$1,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
     "~run"(dataset, config$1) {
       for (const item of pipe$1) if (item.kind !== "metadata") {
         if (dataset.issues && (item.kind === "schema" || item.kind === "transformation")) {
@@ -35735,7 +36061,7 @@ function pipe(...pipe$1) {
       }
       return dataset;
     }
-  };
+  });
 }
 // @__NO_SIDE_EFFECTS__
 function safeParse(schema, input, config$1) {
@@ -35747,7 +36073,7 @@ function safeParse(schema, input, config$1) {
     issues: dataset.issues
   };
 }
-var store$4, DEFAULT_CONFIG, store$3, store$2, store$1, _standardCache, ValiError, EMOJI_REGEX, ABORT_EARLY_CONFIG;
+var store$4, DEFAULT_CONFIG, store$3, store$2, store$1, ValiError, EMOJI_REGEX, ABORT_EARLY_CONFIG;
 var init_dist = __esm({
   "node_modules/valibot/dist/index.mjs"() {
     DEFAULT_CONFIG = {
@@ -35756,7 +36082,6 @@ var init_dist = __esm({
       abortEarly: void 0,
       abortPipeEarly: void 0
     };
-    _standardCache = /* @__PURE__ */ new WeakMap();
     ValiError = class extends Error {
       /**
       * Creates a Valibot error with useful information.
@@ -112869,6 +113194,22 @@ function createGenerationContext(exportData, diagnostics, docs = EMPTY_UNITY_COD
     `${exportData.project.name}Neo`,
     "NeoProject"
   );
+  const enums = Object.values(exportData.enums);
+  const enumNames = buildEnumNameMap(enums, diagnostics);
+  const typeNames = buildNameMap(
+    Object.values(exportData.classes),
+    "Type",
+    diagnostics
+  );
+  const interfaceNames = buildNameMap(
+    Object.values(exportData.interfaces),
+    "Interface",
+    diagnostics
+  );
+  const dialogueGroupClassNames = buildDialogueGroupClassNameMap(
+    dialogueGroups,
+    diagnostics
+  );
   return {
     exportData,
     docs,
@@ -112876,22 +113217,23 @@ function createGenerationContext(exportData, diagnostics, docs = EMPTY_UNITY_COD
     classes: Object.values(exportData.classes),
     interfaces: Object.values(exportData.interfaces),
     diagnostics,
-    enumNames: buildEnumNameMap(Object.values(exportData.enums), diagnostics),
-    enumOptionFieldNames: /* @__PURE__ */ new Map(),
-    typeNames: buildNameMap(
-      Object.values(exportData.classes),
-      "Type",
-      diagnostics
-    ),
-    interfaceNames: buildNameMap(
-      Object.values(exportData.interfaces),
-      "Interface",
-      diagnostics
-    ),
-    dialogueGroupClassNames: buildDialogueGroupClassNameMap(
-      dialogueGroups,
+    enumNames,
+    enumOptionsNames: buildEnumOptionsNameMap(
+      enums,
+      enumNames,
+      [
+        projectClassName,
+        ...enumNames.values(),
+        ...typeNames.values(),
+        ...interfaceNames.values(),
+        ...dialogueGroupClassNames.values()
+      ],
       diagnostics
     ),
+    enumOptionFieldNames: /* @__PURE__ */ new Map(),
+    typeNames,
+    interfaceNames,
+    dialogueGroupClassNames,
     dialogueGroupPropertyNames: buildDialogueGroupPropertyNameMap(
       dialogueGroups,
       diagnostics
@@ -112972,6 +113314,29 @@ function buildEnumNameMap(enums, diagnostics) {
   }
   return names;
 }
+function buildEnumOptionsNameMap(enums, enumNames, typeNames, diagnostics) {
+  const taken = new Set(typeNames);
+  const names = /* @__PURE__ */ new Map();
+  for (const enumDef of enums) {
+    const enumName = enumNames.get(enumDef.id);
+    if (enumName === void 0) continue;
+    const baseName = `${enumName}Options`;
+    if (sdkRuntimeEnumBinding(enumDef.id) !== void 0 || !taken.has(baseName)) {
+      taken.add(baseName);
+      names.set(enumDef.id, baseName);
+      continue;
+    }
+    const uniqueName = `${baseName}_${shortId(enumDef.id)}`;
+    diagnostics.push({
+      severity: "warning",
+      message: `Generated C# options class "${baseName}" for enum "${enumDef.name}" collides with another generated type; using "${uniqueName}".`,
+      path: `enums.${enumDef.id}.name`
+    });
+    taken.add(uniqueName);
+    names.set(enumDef.id, uniqueName);
+  }
+  return names;
+}
 function buildDialogueGroupClassNameMap(groups, diagnostics) {
   const baseNames = buildNameMap(groups, "DialogueGroup", diagnostics);
   const used = /* @__PURE__ */ new Map();
@@ -146676,8 +147041,13 @@ function staticDelegate(target, parameters) {
   const list = parameters.join(", ");
   return `static (${list}) => ${target}(${list})`;
 }
-function enumParser(enumName) {
-  return staticDelegate(`${enumName}.FromOptionId`, ["factoryOptionId"]);
+function enumOptionsName(ctx, enumId) {
+  return ctx.enumOptionsNames.get(enumId) ?? "NeoEnumOptions";
+}
+function enumParser(ctx, enumId) {
+  return staticDelegate(`${enumOptionsName(ctx, enumId)}.FromOptionId`, [
+    "factoryOptionId"
+  ]);
 }
 function immediateInvocationArguments(receiver, argumentNames) {
   const values = argumentNames.length === 1 ? [`(object?)(${argumentNames[0]})`] : argumentNames.length <= 4 ? argumentNames : [`new object?[] { ${argumentNames.join(", ")} }`];
@@ -146691,10 +147061,7 @@ function enumOptionFieldName(ctx, enumId, optionId) {
     const enumDef = ctx.exportData.enums[enumId];
     if (enumDef !== void 0) {
       const enumName = ctx.enumNames.get(enumId) ?? toCSharpTypeName(enumDef.name, "NeoEnum");
-      const taken = /* @__PURE__ */ new Set([
-        enumName,
-        ...GENERATED_ENUM_CLASS_MEMBER_NAMES
-      ]);
+      const taken = /* @__PURE__ */ new Set(["value__"]);
       for (const key of getEnumOptionKeyOrder(enumDef)) {
         const option = enumDef.options[key];
         if (option === void 0) continue;
@@ -146707,7 +147074,7 @@ function enumOptionFieldName(ctx, enumId, optionId) {
           unique = `${preferred}_${ordinal}`;
           ctx.diagnostics.push({
             severity: "warning",
-            message: `Enum option "${option.name}" collides with a member the generated C# enum class "${enumName}" declares; using "${unique}".`,
+            message: `Enum option "${option.name}" collides with another member of the generated C# enum "${enumName}"; using "${unique}".`,
             path: `enums.${enumId}.options.${key}`
           });
         }
@@ -146718,118 +147085,141 @@ function enumOptionFieldName(ctx, enumId, optionId) {
   }
   return names.get(optionId) ?? null;
 }
+function enumMemberValue(optionId) {
+  let hash = 2166136261;
+  for (let index = 0; index < optionId.length; index++) {
+    hash = Math.imul(hash ^ optionId.charCodeAt(index), 16777619);
+  }
+  return (hash >>> 0) % 2147483647 + 1;
+}
 function generateEnumClass(ctx, enumId) {
   const enumDef = ctx.exportData.enums[enumId];
   if (enumDef === void 0) return [];
   if (sdkRuntimeEnumBinding(enumId) !== void 0) return [];
   const enumName = ctx.enumNames.get(enumId) ?? toCSharpTypeName(enumDef.name, "NeoEnum");
-  const optionKeyOrder = getEnumOptionKeyOrder(enumDef);
+  const optionsName = enumOptionsName(ctx, enumId);
+  const optionsByValue = /* @__PURE__ */ new Map();
+  const options = getEnumOptionKeyOrder(enumDef).flatMap((optionId) => {
+    const option = enumDef.options[optionId];
+    if (option === void 0) {
+      throw new Error(
+        `Enum ${enumId} option order references missing option ${optionId}.`
+      );
+    }
+    const fieldName = enumOptionFieldName(ctx, enumId, optionId);
+    if (fieldName === null) {
+      ctx.diagnostics.push({
+        severity: "error",
+        message: `Enum option name "${option.name}" is not a valid C# identifier.`,
+        path: `enums.${enumId}.options.${optionId}`
+      });
+      return [];
+    }
+    const value = enumMemberValue(optionId);
+    const clash = optionsByValue.get(value);
+    if (clash !== void 0) {
+      ctx.diagnostics.push({
+        severity: "error",
+        message: `Enum options "${clash}" and "${option.name}" generate the same C# enum value; recreate one of them to give it a new option id.`,
+        path: `enums.${enumId}.options.${optionId}`
+      });
+      return [];
+    }
+    optionsByValue.set(value, option.name);
+    return [
+      {
+        optionId,
+        value,
+        id: `"${escapeCSharpString(optionId)}"`,
+        member: `${enumName}.${fieldName}`,
+        fieldName,
+        text: `"${escapeCSharpString(option.text)}"`
+      }
+    ];
+  });
+  const switchBody = (subject, arms, fallback) => [
+    `return ${subject} switch`,
+    "{",
+    ...indent([...arms, `_ => ${fallback},`]),
+    "};"
+  ];
+  const method2 = (signature, body) => [
+    signature,
+    "{",
+    ...indent(body),
+    "}"
+  ];
   return [
     ...xmlSummary(ctx.docs.enums[enumId]),
-    `public sealed class ${enumName} : IEquatable<${enumName}>, global::NeoCompose.Runtime.INeoEnumOption`,
+    `[NeoEnum(typeof(${optionsName}))]`,
+    `public enum ${enumName}`,
+    "{",
+    ...indent(
+      options.flatMap((option) => [
+        ...xmlSummary(ctx.docs.enumOptions[option.optionId]),
+        `${option.fieldName} = ${option.value},`
+      ])
+    ),
+    "}",
+    "",
+    "/// <summary>",
+    `/// Converts <see cref="${enumName}"/> to and from the option ids Neo stores.`,
+    "/// </summary>",
+    `public static class ${optionsName}`,
     "{",
     ...indent([
-      `private static readonly Dictionary<string, ${enumName}> values = new Dictionary<string, ${enumName}>();`,
-      "public string optionId { get; }",
-      "public string Text => TextForOptionId(optionId);",
-      "public string TextId => TextIdForOptionId(optionId);",
-      "",
-      `private ${enumName}(string optionId)`,
-      "{",
-      ...indent(["this.optionId = optionId;"]),
-      "}",
-      "",
-      ...optionKeyOrder.flatMap((optionId) => {
-        const option = enumDef.options[optionId];
-        if (option === void 0) {
-          throw new Error(
-            `Enum ${enumId} option order references missing option ${optionId}.`
-          );
-        }
-        const optionName = option.name;
-        const fieldName = enumOptionFieldName(ctx, enumId, optionId);
-        if (fieldName === null) {
-          ctx.diagnostics.push({
-            severity: "error",
-            message: `Enum option name "${optionName}" is not a valid C# identifier.`,
-            path: `enums.${enumId}.options.${optionId}`
-          });
-          return [`// Skipped invalid option id: ${optionId}`];
-        }
-        return [
-          ...xmlSummary(ctx.docs.enumOptions[optionId]),
-          `public static readonly ${enumName} ${fieldName} = FromOptionId("${escapeCSharpString(optionId)}");`
-        ];
-      }),
-      "",
-      `public static ${enumName} FromOptionId(string optionId)`,
-      "{",
-      ...indent([
-        "if (values.TryGetValue(optionId, out var known)) return known;",
-        `var created = new ${enumName}(optionId);`,
-        "values[optionId] = created;",
-        "return created;"
-      ]),
-      "}",
+      ...method2(
+        `public static ${enumName} FromOptionId(string optionId)`,
+        switchBody(
+          "optionId",
+          options.map((option) => `${option.id} => ${option.member},`),
+          `NeoUndeclaredEnumOptions<${enumName}>.FromOptionId(optionId)`
+        )
+      ),
       "",
-      `public static string[] ToOptionIds(IEnumerable<${enumName}>? options)`,
-      "{",
-      ...indent([
-        "if (options is null) return Array.Empty<string>();",
-        "var ids = new List<string>();",
-        "foreach (var option in options) ids.Add(option.optionId);",
-        "return ids.ToArray();"
-      ]),
-      "}",
+      ...method2(
+        `public static string OptionId(this ${enumName} value)`,
+        switchBody(
+          "value",
+          options.map((option) => `${option.member} => ${option.id},`),
+          `NeoUndeclaredEnumOptions<${enumName}>.OptionId(value)`
+        )
+      ),
       "",
-      "public static bool IsKnown(string id)",
-      "{",
-      ...indent([
-        "return id switch",
-        "{",
-        ...indent([
-          ...optionKeyOrder.map(
-            (optionId) => `"${escapeCSharpString(optionId)}" => true,`
-          ),
-          "_ => false,"
-        ]),
-        "};"
-      ]),
-      "}",
+      ...method2(
+        `public static string[] ToOptionIds(IEnumerable<${enumName}>? options)`,
+        [
+          "if (options is null) return Array.Empty<string>();",
+          "var ids = new List<string>();",
+          "foreach (var option in options) ids.Add(option.OptionId());",
+          "return ids.ToArray();"
+        ]
+      ),
       "",
-      "public static string TextIdForOptionId(string optionId)",
-      "{",
-      ...indent([
-        "return optionId switch",
-        "{",
-        ...indent([
-          ...optionKeyOrder.flatMap((optionId) => {
-            const option = enumDef.options[optionId];
-            return [
-              `"${escapeCSharpString(optionId)}" => "${escapeCSharpString(option.text)}",`
-            ];
-          }),
-          "_ => optionId,"
-        ]),
-        "};"
-      ]),
-      "}",
+      ...method2(
+        "public static bool IsKnown(string optionId)",
+        switchBody(
+          "optionId",
+          options.map((option) => `${option.id} => true,`),
+          "false"
+        )
+      ),
       "",
-      "public static string TextForOptionId(string optionId, NeoClient? client = null)",
-      "{",
-      ...indent([
-        ctx.singleton ? `return (client ?? ${ctx.projectClassName}.RequireInstance().Client).Localization.ResolveText(TextIdForOptionId(optionId));` : "return client is null ? TextIdForOptionId(optionId) : client.Localization.ResolveText(TextIdForOptionId(optionId));"
-      ]),
-      "}",
+      ...method2(
+        `public static string TextId(this ${enumName} value)`,
+        switchBody(
+          "value",
+          options.map((option) => `${option.member} => ${option.text},`),
+          "value.OptionId()"
+        )
+      ),
       "",
-      `public static implicit operator string(${enumName} value) => value.optionId;`,
-      `public static implicit operator ${enumName}(string optionId) => FromOptionId(optionId);`,
-      "public override string ToString() => optionId;",
-      `public bool Equals(${enumName}? other) => other is not null && optionId == other.optionId;`,
-      `public override bool Equals(object? obj) => Equals(obj as ${enumName});`,
-      "public override int GetHashCode() => optionId.GetHashCode();",
-      `public static bool operator ==(${enumName}? left, ${enumName}? right) => ReferenceEquals(left, right) || (left is not null && left.Equals(right));`,
-      `public static bool operator !=(${enumName}? left, ${enumName}? right) => !(left == right);`
+      ...method2(
+        `public static string Text(this ${enumName} value, NeoClient? client = null)`,
+        [
+          ctx.singleton ? `return (client ?? ${ctx.projectClassName}.RequireInstance().Client).Localization.ResolveText(value.TextId());` : "return client is null ? value.TextId() : client.Localization.ResolveText(value.TextId());"
+        ]
+      )
     ]),
     "}"
   ];
@@ -147059,7 +147449,7 @@ function generateIndexedListWrappers(ctx, ownerClass, schemaKey, memberId, env)
         {
           definition: definition2,
           keyType: enumName,
-          codecs: enumKeyCodecArguments(indexedMember.enumId, enumName)
+          codecs: enumKeyCodecArguments(ctx, indexedMember.enumId)
         }
       ];
     }
@@ -148329,7 +148719,7 @@ function generateExplicitInterfaceMember(ctx, schemaKey, memberId, interfaceName
     genericEnv,
     ownerClassId
   );
-  const setter = isMemberNSPropertyBase(member) && typeof member.setterCode === "string" && !suppressesInheritedSetter(interfaceContract) ? nsPropertyWriteExpression(schemaKey) : null;
+  const setter = isMemberNSPropertyBase(member) && typeof member.setterCode === "string" && !suppressesInheritedSetter(interfaceContract) ? nsPropertyWriteExpression(ctx, member, schemaKey) : null;
   return [
     `${interfaceType2} ${interfaceName}.${memberName}`,
     "{",
@@ -149083,7 +149473,7 @@ function planWorldObjectEmission(ctx, classDef, worldKind) {
         // conversion runs through the wrapper's implicit operator, which is
         // where the required-member throw now lives.
         `Sprite ${SPRITE_OBJECT_VALUE_INTERFACE}.${schemaKeyToMemberName(SPRITE_OBJECT_SPRITE_SCHEMA_KEY)} => ${schemaKeyToMemberName(SPRITE_OBJECT_SPRITE_SCHEMA_KEY)};`,
-        `string ${SPRITE_OBJECT_VALUE_INTERFACE}.${schemaKeyToMemberName(SPRITE_OBJECT_MASK_INTERACTION_SCHEMA_KEY)} => ${schemaKeyToMemberName(SPRITE_OBJECT_MASK_INTERACTION_SCHEMA_KEY)}.optionId;`
+        `string ${SPRITE_OBJECT_VALUE_INTERFACE}.${schemaKeyToMemberName(SPRITE_OBJECT_MASK_INTERACTION_SCHEMA_KEY)} => ${schemaKeyToMemberName(SPRITE_OBJECT_MASK_INTERACTION_SCHEMA_KEY)}.OptionId();`
       ],
       shadowedSchemaKeys: /* @__PURE__ */ new Set([
         SPRITE_OBJECT_SPRITE_SCHEMA_KEY,
@@ -149105,7 +149495,7 @@ function planSmartTileEmission(ctx, classDef) {
     return planValidatedContractEmission(ctx, classDef, worldKind, () => ({
       runtimeInterfaces: [SMART_TILE_INTERFACE],
       classMembers: [
-        `string ${SMART_TILE_INTERFACE}.${schemaKeyToMemberName(WORLD_SMART_TILE_DEFAULT_COLLIDER_SCHEMA_KEY)} => ${schemaKeyToMemberName(WORLD_SMART_TILE_DEFAULT_COLLIDER_SCHEMA_KEY)}.optionId;`,
+        `string ${SMART_TILE_INTERFACE}.${schemaKeyToMemberName(WORLD_SMART_TILE_DEFAULT_COLLIDER_SCHEMA_KEY)} => ${schemaKeyToMemberName(WORLD_SMART_TILE_DEFAULT_COLLIDER_SCHEMA_KEY)}.OptionId();`,
         `IReadOnlyList<${SMART_TILE_RULE_INTERFACE}> ${SMART_TILE_INTERFACE}.${schemaKeyToMemberName(WORLD_SMART_TILE_RULES_SCHEMA_KEY)} => ${schemaKeyToMemberName(WORLD_SMART_TILE_RULES_SCHEMA_KEY)};`
       ],
       shadowedSchemaKeys: /* @__PURE__ */ new Set([
@@ -149120,9 +149510,9 @@ function planSmartTileEmission(ctx, classDef) {
       classMembers: [
         `IReadOnlyList<${SMART_TILE_NEIGHBOR_INTERFACE}> ${SMART_TILE_RULE_INTERFACE}.${schemaKeyToMemberName(WORLD_SMART_TILE_RULE_NEIGHBORS_SCHEMA_KEY)} => ${schemaKeyToMemberName(WORLD_SMART_TILE_RULE_NEIGHBORS_SCHEMA_KEY)};`,
         `IReadOnlyList<Sprite> ${SMART_TILE_RULE_INTERFACE}.${schemaKeyToMemberName(WORLD_SMART_TILE_RULE_SPRITES_SCHEMA_KEY)} => ${schemaKeyToMemberName(WORLD_SMART_TILE_RULE_SPRITES_SCHEMA_KEY)};`,
-        `string ${SMART_TILE_RULE_INTERFACE}.${schemaKeyToMemberName(WORLD_SMART_TILE_RULE_OUTPUT_SCHEMA_KEY)} => ${schemaKeyToMemberName(WORLD_SMART_TILE_RULE_OUTPUT_SCHEMA_KEY)}.optionId;`,
-        `string ${SMART_TILE_RULE_INTERFACE}.${schemaKeyToMemberName(WORLD_SMART_TILE_RULE_COLLIDER_SCHEMA_KEY)} => ${schemaKeyToMemberName(WORLD_SMART_TILE_RULE_COLLIDER_SCHEMA_KEY)}.optionId;`,
-        `string ${SMART_TILE_RULE_INTERFACE}.${schemaKeyToMemberName(WORLD_SMART_TILE_RULE_TRANSFORM_SCHEMA_KEY)} => ${schemaKeyToMemberName(WORLD_SMART_TILE_RULE_TRANSFORM_SCHEMA_KEY)}.optionId;`,
+        `string ${SMART_TILE_RULE_INTERFACE}.${schemaKeyToMemberName(WORLD_SMART_TILE_RULE_OUTPUT_SCHEMA_KEY)} => ${schemaKeyToMemberName(WORLD_SMART_TILE_RULE_OUTPUT_SCHEMA_KEY)}.OptionId();`,
+        `string ${SMART_TILE_RULE_INTERFACE}.${schemaKeyToMemberName(WORLD_SMART_TILE_RULE_COLLIDER_SCHEMA_KEY)} => ${schemaKeyToMemberName(WORLD_SMART_TILE_RULE_COLLIDER_SCHEMA_KEY)}.OptionId();`,
+        `string ${SMART_TILE_RULE_INTERFACE}.${schemaKeyToMemberName(WORLD_SMART_TILE_RULE_TRANSFORM_SCHEMA_KEY)} => ${schemaKeyToMemberName(WORLD_SMART_TILE_RULE_TRANSFORM_SCHEMA_KEY)}.OptionId();`,
         `float ${SMART_TILE_RULE_INTERFACE}.${schemaKeyToMemberName(WORLD_SMART_TILE_RULE_MIN_ANIMATION_SPEED_SCHEMA_KEY)} => ${schemaKeyToMemberName(WORLD_SMART_TILE_RULE_MIN_ANIMATION_SPEED_SCHEMA_KEY)};`,
         `float ${SMART_TILE_RULE_INTERFACE}.${schemaKeyToMemberName(WORLD_SMART_TILE_RULE_MAX_ANIMATION_SPEED_SCHEMA_KEY)} => ${schemaKeyToMemberName(WORLD_SMART_TILE_RULE_MAX_ANIMATION_SPEED_SCHEMA_KEY)};`
       ],
@@ -149142,7 +149532,7 @@ function planSmartTileEmission(ctx, classDef) {
       runtimeInterfaces: [SMART_TILE_NEIGHBOR_INTERFACE],
       classMembers: [
         `Vector2Int ${SMART_TILE_NEIGHBOR_INTERFACE}.${schemaKeyToMemberName(WORLD_SMART_TILE_NEIGHBOR_CELL_SCHEMA_KEY)} => ${schemaKeyToMemberName(WORLD_SMART_TILE_NEIGHBOR_CELL_SCHEMA_KEY)}.Value;`,
-        `string ${SMART_TILE_NEIGHBOR_INTERFACE}.${schemaKeyToMemberName(WORLD_SMART_TILE_NEIGHBOR_CONDITION_SCHEMA_KEY)} => ${schemaKeyToMemberName(WORLD_SMART_TILE_NEIGHBOR_CONDITION_SCHEMA_KEY)}.optionId;`,
+        `string ${SMART_TILE_NEIGHBOR_INTERFACE}.${schemaKeyToMemberName(WORLD_SMART_TILE_NEIGHBOR_CONDITION_SCHEMA_KEY)} => ${schemaKeyToMemberName(WORLD_SMART_TILE_NEIGHBOR_CONDITION_SCHEMA_KEY)}.OptionId();`,
         `string? ${SMART_TILE_NEIGHBOR_INTERFACE}.TileClassId => ${SMART_TILE_NEIGHBOR_TILE_RELATION_EXPRESSION};`
       ],
       shadowedSchemaKeys: /* @__PURE__ */ new Set([
@@ -150366,37 +150756,16 @@ function declaredConstructorParameters(ctx, classId, declared, genericEnv) {
     }
     identifiers.add(identifier2);
     const baseType = csharpFunctionTypeInfoValueType(ctx, argument2, true, genericEnv) ?? "object?";
-    const rendered = renderCSharpParameterDefault(
-      ctx,
-      argument2,
-      `constructors.${declared.id}.argumentTypes`
-    );
-    if (rendered === null) {
-      parameters.push({
-        declaredName: argument2.name,
-        identifier: identifier2,
-        csharpType: baseType,
-        defaultLiteral: null,
-        enumFallback: null
-      });
-      continue;
-    }
-    if (rendered.enumFallback === null) {
-      parameters.push({
-        declaredName: argument2.name,
-        identifier: identifier2,
-        csharpType: baseType,
-        defaultLiteral: rendered.literal,
-        enumFallback: null
-      });
-      continue;
-    }
     parameters.push({
       declaredName: argument2.name,
       identifier: identifier2,
-      csharpType: baseType.endsWith("?") ? baseType : `${baseType}?`,
-      defaultLiteral: rendered.literal,
-      enumFallback: rendered.enumFallback
+      csharpType: baseType,
+      defaultLiteral: renderCSharpParameterDefault(
+        ctx,
+        argument2,
+        `constructors.${declared.id}.argumentTypes`
+      ),
+      scriptArgument: scriptValueExpression(ctx, argument2, identifier2)
     });
   }
   return parameters;
@@ -150470,10 +150839,9 @@ function generateDeclaredConstructor(ctx, classId, className, constructorId, par
   );
   const signatureParameters = [...declaredParameters, ...appendedParameters];
   const parameterText = ctx.singleton ? signatureParameters.join(", ") : [`${ctx.projectClassName} project`, ...signatureParameters].join(", ");
-  const argumentEntries = parameters.map((parameter4) => {
-    const valueExpression = parameter4.enumFallback === null ? parameter4.identifier : `${parameter4.identifier} ?? ${parameter4.enumFallback}`;
-    return `new global::NeoCompose.Runtime.NeoDeclaredConstructorArgument("${escapeCSharpString(parameter4.declaredName)}", ${valueExpression})`;
-  }).join(", ");
+  const argumentEntries = parameters.map(
+    (parameter4) => `new global::NeoCompose.Runtime.NeoDeclaredConstructorArgument("${escapeCSharpString(parameter4.declaredName)}", ${parameter4.scriptArgument})`
+  ).join(", ");
   const argumentArray = argumentEntries.length === 0 ? "new global::NeoCompose.Runtime.NeoDeclaredConstructorArgument[] { }" : `new global::NeoCompose.Runtime.NeoDeclaredConstructorArgument[] { ${argumentEntries} }`;
   const suppliedValues = appendedMembers.map(
     (member) => `new global::NeoCompose.Runtime.NeoGeneratedConstructorValue("${escapeCSharpString(member.schemaKey)}", "${escapeCSharpString(member.memberId)}", ${member.identifier})`
@@ -150590,21 +150958,18 @@ function generateStaticFunctionMethod(ctx, ownerClass, member, genericEnv) {
     `members.${member.id}.argumentTypes`
   );
   const parameters = parameterList.map((parameter4) => parameter4.declaration).join(", ");
-  const coalesceStatements = parameterList.flatMap(
-    (parameter4) => parameter4.coalesceStatement === null ? [] : [parameter4.coalesceStatement]
+  const argumentNames = parameterList.map((parameter4) => parameter4.identifier);
+  const scriptArguments = parameterList.map(
+    (parameter4) => parameter4.scriptArgument
   );
-  const argumentNames = parameterList.map(
-    (parameter4) => parameter4.valueExpression
-  );
-  const args = argumentNames.length === 0 ? "{ }" : `{ ${argumentNames.join(", ")} }`;
+  const args = scriptArguments.length === 0 ? "{ }" : `{ ${scriptArguments.join(", ")} }`;
   const asyncModifier = member.kind === 23 /* NSFunction */ && callableIsDeferred(member) ? "async " : "";
   const declaration = `${memberAccessKeyword(member)} static ${asyncModifier}${returnType} ${functionMethodName(member.name)}(${parameters})`;
   const docs = xmlSummary(ctx.docs.members[member.id]);
   const stamp = memberMethodStamp(member);
   if (member.kind === 23 /* NSFunction */) {
-    const invocation = callableIsDeferred(member) ? `await node.InvokeStaticAsync(new object?[] ${args})` : `node.InvokeStatic(${immediateInvocationArguments(null, argumentNames)})`;
+    const invocation = callableIsDeferred(member) ? `await node.InvokeStaticAsync(new object?[] ${args})` : `node.InvokeStatic(${immediateInvocationArguments(null, scriptArguments)})`;
     const body = [
-      ...coalesceStatements,
       `var client = ${ctx.projectClassName}.RequireInstance().Client;`,
       `var node = NeoMemberNSFunction.GetOrCreateStatic(client, "${escapeCSharpString(member.id)}");`,
       ...isFunctionVoidTypeInfo(member.returnTypeInfo) ? [`${invocation};`] : [
@@ -150641,7 +151006,6 @@ function generateStaticFunctionMethod(ctx, ownerClass, member, genericEnv) {
     declaration,
     "{",
     ...indent([
-      ...coalesceStatements,
       `if (${handler} is null)`,
       "{",
       ...indent([
@@ -150874,7 +151238,7 @@ function generateStaticNSProperty(ctx, member, memberName, memberId, genericEnv)
   ];
   const setter = typeof member.setterCode === "string" ? [
     ...prelude,
-    "var result = node.Set(value);",
+    `var result = node.Set(${scriptValueExpression(ctx, member.returnTypeInfo, "value")});`,
     'if (!result.ok) throw new InvalidOperationException(result.error ?? "Static NSProperty setter failed.");'
   ] : null;
   return [
@@ -151044,7 +151408,7 @@ function generateMember(ctx, schemaKey, memberId, saved, modifier, emitBody, own
     genericEnv,
     ownerClassId
   );
-  const declaredPropertySetter = isMemberNSPropertyBase(member) && typeof member.setterCode === "string" ? nsPropertyWriteExpression(schemaKey) : null;
+  const declaredPropertySetter = isMemberNSPropertyBase(member) && typeof member.setterCode === "string" ? nsPropertyWriteExpression(ctx, member, schemaKey) : null;
   const propertySetter = suppressesInheritedSetter(inheritedContract) ? null : declaredPropertySetter;
   const emitsStoredSetter = bindingContract === null ? memberSaved : bindingContract.hasSetter;
   const storedSetterBody = suppressesInheritedSetter(inheritedContract) || !emitsStoredSetter ? null : writeExpression(ctx, member, schemaKey, ownerClassName, ownerClassId);
@@ -151397,10 +151761,10 @@ function descendsFromWorldObject(ctx, classId) {
   }
   return false;
 }
-function nsPropertyWriteExpression(schemaKey) {
+function nsPropertyWriteExpression(ctx, member, schemaKey) {
   const getNode = `writableNode.Get<NeoMemberNSProperty>("${escapeCSharpString(schemaKey)}")`;
   return [
-    `var result = ${getNode}.Set(valueId!, value);`,
+    `var result = ${getNode}.Set(valueId!, ${scriptValueExpression(ctx, member.returnTypeInfo, "value")});`,
     'if (!result.ok) throw new InvalidOperationException(result.error ?? "NSProperty setter failed.");'
   ];
 }
@@ -151470,49 +151834,37 @@ function renderCSharpParameterDefault(ctx, argument2, path) {
     case 1 /* Bool */: {
       const defaultValue = argument2.defaultValue;
       if (defaultValue === void 0) return null;
-      if (defaultValue.value === null)
-        return { literal: "null", enumFallback: null };
-      return {
-        literal: defaultValue.value ? "true" : "false",
-        enumFallback: null
-      };
+      if (defaultValue.value === null) return "null";
+      return defaultValue.value ? "true" : "false";
     }
     case 2 /* Int */: {
       const defaultValue = argument2.defaultValue;
       if (defaultValue === void 0) return null;
-      if (defaultValue.value === null)
-        return { literal: "null", enumFallback: null };
-      return { literal: String(defaultValue.value), enumFallback: null };
+      if (defaultValue.value === null) return "null";
+      return String(defaultValue.value);
     }
     case 4 /* Float */: {
       const defaultValue = argument2.defaultValue;
       if (defaultValue === void 0) return null;
-      if (defaultValue.value === null)
-        return { literal: "null", enumFallback: null };
-      return { literal: `${String(defaultValue.value)}f`, enumFallback: null };
+      if (defaultValue.value === null) return "null";
+      return `${String(defaultValue.value)}f`;
     }
     case 20 /* Decimal */: {
       const defaultValue = argument2.defaultValue;
       if (defaultValue === void 0) return null;
-      if (defaultValue.value === null)
-        return { literal: "null", enumFallback: null };
-      return { literal: `${defaultValue.value}m`, enumFallback: null };
+      if (defaultValue.value === null) return "null";
+      return `${defaultValue.value}m`;
     }
     case 3 /* String */: {
       const defaultValue = argument2.defaultValue;
       if (defaultValue === void 0) return null;
-      if (defaultValue.value === null)
-        return { literal: "null", enumFallback: null };
-      return {
-        literal: `"${escapeCSharpString(defaultValue.value)}"`,
-        enumFallback: null
-      };
+      if (defaultValue.value === null) return "null";
+      return `"${escapeCSharpString(defaultValue.value)}"`;
     }
     case 8 /* Enum */: {
       const defaultValue = argument2.defaultValue;
       if (defaultValue === void 0) return null;
-      if (defaultValue.value === null)
-        return { literal: "null", enumFallback: null };
+      if (defaultValue.value === null) return "null";
       const enumDef = ctx.exportData.enums[argument2.enumId];
       if (enumDef === void 0) {
         ctx.diagnostics.push({
@@ -151554,22 +151906,22 @@ function renderCSharpParameterDefault(ctx, argument2, path) {
         return null;
       }
       if (argument2.enumId === NEO_CELL_PATTERN_EXCLUDING_ENUM_ID)
-        return {
-          literal: `NeoCompose.Runtime.NeoCellPatternExcluding.${schemaKeyToMemberName(option.name)}`,
-          enumFallback: null
-        };
-      return { literal: "null", enumFallback: `${enumName}.${accessor}` };
+        return `NeoCompose.Runtime.NeoCellPatternExcluding.${schemaKeyToMemberName(option.name)}`;
+      return `${enumName}.${accessor}`;
     }
     default: {
       if (argument2.defaultValue === void 0) return null;
-      return { literal: "null", enumFallback: null };
+      return "null";
     }
   }
 }
+function scriptValueExpression(ctx, typeInfo, expression) {
+  return typeInfo.type === 8 /* Enum */ && typeInfo.enumId !== NEO_CELL_PATTERN_EXCLUDING_ENUM_ID && ctx.enumNames.has(typeInfo.enumId) ? `${expression}${typeInfo.required ? "" : "?"}.OptionId()` : expression;
+}
 function renderFunctionParameters(ctx, member, genericBindingSaved, genericEnv, path) {
   return member.argumentTypes.map((argument2, index) => {
     const identifier2 = functionParameterName(argument2.name, index);
-    const baseType = csharpFunctionTypeInfoValueType(
+    const type = csharpFunctionTypeInfoValueType(
       ctx,
       argument2,
       genericBindingSaved,
@@ -151577,10 +151929,9 @@ function renderFunctionParameters(ctx, member, genericBindingSaved, genericEnv,
     ) ?? "object?";
     const bare = {
       identifier: identifier2,
-      type: baseType,
-      declaration: `${baseType} ${identifier2}`,
-      valueExpression: identifier2,
-      coalesceStatement: null
+      type,
+      declaration: `${type} ${identifier2}`,
+      scriptArgument: scriptValueExpression(ctx, argument2, identifier2)
     };
     if (callableIsDeferred(member) && parameterHasDefault(argument2)) {
       ctx.diagnostics.push({
@@ -151590,26 +151941,8 @@ function renderFunctionParameters(ctx, member, genericBindingSaved, genericEnv,
       });
       return bare;
     }
-    const rendered = renderCSharpParameterDefault(ctx, argument2, path);
-    if (rendered === null) return bare;
-    if (rendered.enumFallback === null) {
-      return {
-        identifier: identifier2,
-        type: baseType,
-        declaration: `${baseType} ${identifier2} = ${rendered.literal}`,
-        valueExpression: identifier2,
-        coalesceStatement: null
-      };
-    }
-    const nullableType = baseType.endsWith("?") ? baseType : `${baseType}?`;
-    const coalescedLocal = `${identifier2}Value`;
-    return {
-      identifier: identifier2,
-      type: nullableType,
-      declaration: `${nullableType} ${identifier2} = null`,
-      valueExpression: coalescedLocal,
-      coalesceStatement: `var ${coalescedLocal} = ${identifier2} ?? ${rendered.enumFallback};`
-    };
+    const literal3 = renderCSharpParameterDefault(ctx, argument2, path);
+    return literal3 === null ? bare : { ...bare, declaration: `${type} ${identifier2} = ${literal3}` };
   });
 }
 function functionSignature(ctx, member, genericEnv) {
@@ -151677,12 +152010,12 @@ function generateFunctionMethod(ctx, member, schemaKey, modifier = "", emitBody
   ];
   if (!emitBody) return [...docs, `${declaration};`];
   const stamp = memberMethodStamp(member);
-  const coalesceStatements = parameterList.flatMap(
-    (parameter4) => parameter4.coalesceStatement === null ? [] : [parameter4.coalesceStatement]
-  );
-  const argumentList = parameterList.map((parameter4) => parameter4.valueExpression).join(", ");
+  const argumentList = parameterList.map((parameter4) => parameter4.identifier).join(", ");
   const call = `FunctionHandler.${methodName}(${argumentList})`;
-  const deferredArgs = member.argumentTypes.length === 0 ? "{ }" : `{ ${argumentList} }`;
+  const scriptArguments = parameterList.map(
+    (parameter4) => parameter4.scriptArgument
+  );
+  const deferredArgs = scriptArguments.length === 0 ? "{ }" : `{ ${scriptArguments.join(", ")} }`;
   const deferredCall = isFunctionVoidTypeInfo(member.returnTypeInfo) ? `return client.InvokeDeferredNativeFunction("${escapeCSharpString(member.id)}", this, new object?[] ${deferredArgs});` : `return client.InvokeDeferredNativeFunction<${csharpFunctionReturnType(ctx, member.returnTypeInfo, genericEnv, true)}>("${escapeCSharpString(member.id)}", this, new object?[] ${deferredArgs});`;
   if (member.id === NEO_TILE_CONVERT_MEMBER_ID) {
     return [
@@ -151690,10 +152023,7 @@ function generateFunctionMethod(ctx, member, schemaKey, modifier = "", emitBody
       ...stamp,
       declaration,
       "{",
-      ...indent([
-        ...coalesceStatements,
-        `return base.TryConvert(${argumentList});`
-      ]),
+      ...indent([`return base.TryConvert(${argumentList});`]),
       "}"
     ];
   }
@@ -151704,7 +152034,6 @@ function generateFunctionMethod(ctx, member, schemaKey, modifier = "", emitBody
       declaration,
       "{",
       ...indent([
-        ...coalesceStatements,
         `var result = client.ScriptGridQueries.Invoke("${member.id}", this, new object?[] ${deferredArgs});`,
         ...nsGetterResultReturnExpression(
           ctx,
@@ -151720,11 +152049,10 @@ function generateFunctionMethod(ctx, member, schemaKey, modifier = "", emitBody
   if (isNSFunction2) {
     const invocation = callableIsDeferred(member) ? `writableNode.Get<NeoMemberNSFunction>("${escapeCSharpString(schemaKey)}").InvokeAsync(valueId!, new object?[] ${deferredArgs})` : `InvokeFunction(${immediateInvocationArguments(
       `"${escapeCSharpString(schemaKey)}"`,
-      parameterList.map((parameter4) => parameter4.valueExpression)
+      scriptArguments
     )})`;
     const resultStatement = callableIsDeferred(member) ? `var result = await ${invocation};` : `var result = ${invocation};`;
     const body = [
-      ...coalesceStatements,
       ...callableIsDeferred(member) ? [
         `if (valueId is null) throw new InvalidOperationException("Cannot invoke NSFunction '${escapeCSharpString(member.name)}' without a backing receiver value id.");`
       ] : [],
@@ -151749,7 +152077,6 @@ function generateFunctionMethod(ctx, member, schemaKey, modifier = "", emitBody
     declaration,
     "{",
     ...indent([
-      ...coalesceStatements,
       ...callableIsDeferred(member) ? [deferredCall] : [
         "if (FunctionHandler is null)",
         "{",
@@ -151822,8 +152149,8 @@ function nativeFunctionArgExpression(ctx, typeInfo, valueExpression, argumentNam
     case 8 /* Enum */: {
       if (typeInfo.enumId === NEO_CELL_PATTERN_EXCLUDING_ENUM_ID)
         return `NeoCellPatternStorage.${required2 ? "ReadExcluding" : "ReadOptionalExcluding"}(${valueExpression})`;
-      const enumName = ctx.enumNames.get(typeInfo.enumId) ?? "string";
-      return required2 ? `NeoGeneratedTypesSupport.ReadEnumSingle(${valueExpression}, ${enumParser(enumName)}) ?? throw new InvalidOperationException("Required enum argument '${escapeCSharpString(argumentName)}' could not be resolved.")` : `NeoGeneratedTypesSupport.ReadEnumSingle(${valueExpression}, ${enumParser(enumName)})`;
+      const parser = enumParser(ctx, typeInfo.enumId);
+      return required2 ? `NeoGeneratedTypesSupport.ReadEnumSingle(${valueExpression}, ${parser}) ?? throw new InvalidOperationException("Required enum argument '${escapeCSharpString(argumentName)}' could not be resolved.")` : `NeoGeneratedTypesSupport.ReadEnumSingle(${valueExpression}, ${parser})`;
     }
     case 18 /* DialogueLookup */: {
       const dialogueIds = `NeoGeneratedTypesSupport.ToStringArray(${valueExpression})`;
@@ -151862,8 +152189,7 @@ function nativeFunctionArgExpression(ctx, typeInfo, valueExpression, argumentNam
       if (isMemberEnumBase(binding) && isMultiSelectionMember(binding)) {
         if (binding.enumId === NEO_CELL_PATTERN_EXCLUDING_ENUM_ID)
           return `NeoCellPatternStorage.ReadExcludingList(${valueExpression})`;
-        const enumName = ctx.enumNames.get(binding.enumId) ?? "string";
-        return `NeoGeneratedTypesSupport.ReadEnumList(${valueExpression}, ${enumParser(enumName)})`;
+        return `NeoGeneratedTypesSupport.ReadEnumList(${valueExpression}, ${enumParser(ctx, binding.enumId)})`;
       }
       if (isMemberClassBase(binding)) {
         const typeName = ctx.typeNames.get(binding.classId);
@@ -152107,10 +152433,9 @@ function nsGetterResultReturnExpression(ctx, returnTypeInfo, valueExpression, sa
           ...prefix,
           `return NeoCellPatternStorage.${optional2 ? "ReadOptionalExcluding" : "ReadExcluding"}(${valueExpression});`
         ];
-      const enumName = ctx.enumNames.get(returnTypeInfo.enumId) ?? "string";
       return [
         ...prefix,
-        `var selected = NeoGeneratedTypesSupport.ReadEnumSingle(${valueExpression}, ${enumParser(enumName)});`,
+        `var selected = NeoGeneratedTypesSupport.ReadEnumSingle(${valueExpression}, ${enumParser(ctx, returnTypeInfo.enumId)});`,
         optional2 ? "return selected;" : 'return selected ?? throw new InvalidOperationException("NSProperty returned null for a required enum value.");'
       ];
     }
@@ -152226,11 +152551,11 @@ function nsGetterGenericResultExpression(ctx, typeInfo, valueExpression, saved,
   if (isMemberEnumBase(binding)) {
     if (binding.enumId === NEO_CELL_PATTERN_EXCLUDING_ENUM_ID)
       return `NeoCellPatternStorage.${isMultiSelectionMember(binding) ? "ReadExcludingList" : required2 ? "ReadExcluding" : "ReadOptionalExcluding"}(${valueExpression})`;
-    const enumName = ctx.enumNames.get(binding.enumId) ?? "string";
+    const parser = enumParser(ctx, binding.enumId);
     if (isMultiSelectionMember(binding)) {
-      return `NeoGeneratedTypesSupport.ReadEnumList(${valueExpression}, ${enumParser(enumName)})`;
+      return `NeoGeneratedTypesSupport.ReadEnumList(${valueExpression}, ${parser})`;
     }
-    const read = `NeoGeneratedTypesSupport.ReadEnumSingle(${valueExpression}, ${enumParser(enumName)})`;
+    const read = `NeoGeneratedTypesSupport.ReadEnumSingle(${valueExpression}, ${parser})`;
     return required2 ? `${read} ?? throw new InvalidOperationException("Required generic enum result was null.")` : read;
   }
   if (isMemberClassBase(binding)) {
@@ -152380,11 +152705,11 @@ function detachedValueExpression(ctx, member, value, required2, saved, genericEn
   if (isMemberEnumBase(member)) {
     if (member.enumId === NEO_CELL_PATTERN_EXCLUDING_ENUM_ID)
       return `NeoCellPatternStorage.${isMultiSelectionMember(member) ? "ReadExcludingList" : required2 ? "ReadExcluding" : "ReadOptionalExcluding"}(${value})`;
-    const enumName = ctx.enumNames.get(member.enumId);
-    if (enumName === void 0) return null;
+    if (!ctx.enumNames.has(member.enumId)) return null;
+    const parser = enumParser(ctx, member.enumId);
     if (isMultiSelectionMember(member))
-      return `NeoGeneratedTypesSupport.ReadEnumList(${value}, ${enumParser(enumName)})`;
-    const read = `NeoGeneratedTypesSupport.ReadEnumSingle(${value}, ${enumParser(enumName)})`;
+      return `NeoGeneratedTypesSupport.ReadEnumList(${value}, ${parser})`;
+    const read = `NeoGeneratedTypesSupport.ReadEnumSingle(${value}, ${parser})`;
     return required2 ? `${read} ?? throw new InvalidOperationException("Required enum '${escapeCSharpString(member.name)}' has no selected option.")` : `${value} is null ? null : ${read}`;
   }
   if (isMemberClassBase(member) && member.classArguments == null) {
@@ -152553,15 +152878,15 @@ function storedReadExpression(ctx, member, schemaKey, nodeType, saved, ownerClas
       return [
         `return NeoCellPatternStorage.${isMultiSelectionMember(member) ? "ReadExcludingList" : isRequiredMember2(member) ? "ReadExcluding" : "ReadOptionalExcluding"}(${getNode}.Selected());`
       ];
-    const enumName = ctx.enumNames.get(member.enumId) ?? "string";
+    const optionsName = enumOptionsName(ctx, member.enumId);
     return isMultiSelectionMember(member) ? [
-      `return NeoGeneratedTypesSupport.ReadEnumList(${getNode}.Selected(), ${enumParser(enumName)});`
+      `return NeoGeneratedTypesSupport.ReadEnumList(${getNode}.Selected(), ${enumParser(ctx, member.enumId)});`
     ] : isRequiredMember2(member) ? [
       `var selected = NeoGeneratedTypesSupport.ReadSingleSelected(${getNode});`,
-      `return selected is null ? throw new InvalidOperationException("Required enum '${escapeCSharpString(schemaKey)}' has no selected option.") : ${enumName}.FromOptionId(selected);`
+      `return selected is null ? throw new InvalidOperationException("Required enum '${escapeCSharpString(schemaKey)}' has no selected option.") : ${optionsName}.FromOptionId(selected);`
     ] : [
       `var selected = NeoGeneratedTypesSupport.ReadSingleSelected(${getNode});`,
-      `return selected is null ? null : ${enumName}.FromOptionId(selected);`
+      `return selected is null ? null : ${optionsName}.FromOptionId(selected);`
     ];
   }
   if (isMemberLookupBase(member)) {
@@ -152718,13 +153043,12 @@ function writeExpression(ctx, member, schemaKey, ownerClassName, ownerClassId) {
       return [
         `NeoGeneratedTypesSupport.SetValue(writableNode, "${key}", NeoGeneratedTypesSupport.Value(NeoCellPatternStorage.${isMultiSelectionMember(member) ? "ExcludingListIds" : "OptionalExcludingIds"}(value)));`
       ];
-    const enumName = ctx.enumNames.get(member.enumId) ?? "string";
     return isMultiSelectionMember(member) ? [
-      `NeoGeneratedTypesSupport.SetValue(writableNode, "${key}", NeoGeneratedTypesSupport.Value(${enumName}.ToOptionIds(value)));`
+      `NeoGeneratedTypesSupport.SetValue(writableNode, "${key}", NeoGeneratedTypesSupport.Value(${enumOptionsName(ctx, member.enumId)}.ToOptionIds(value)));`
     ] : isRequiredMember2(member) ? [
-      `NeoGeneratedTypesSupport.SetValue(writableNode, "${key}", NeoGeneratedTypesSupport.Value(new[] { value.optionId }));`
+      `NeoGeneratedTypesSupport.SetValue(writableNode, "${key}", NeoGeneratedTypesSupport.Value(new[] { value.OptionId() }));`
     ] : [
-      `NeoGeneratedTypesSupport.SetValue(writableNode, "${key}", NeoGeneratedTypesSupport.Value(value is null ? null : new[] { value.optionId }));`
+      `NeoGeneratedTypesSupport.SetValue(writableNode, "${key}", NeoGeneratedTypesSupport.Value(value is null ? null : new[] { value.Value.OptionId() }));`
     ];
   }
   if (isMemberLookupBase(member)) {
@@ -152839,14 +153163,13 @@ function collectionReadExpression(ctx, member, getNode, schemaKey, entryMember,
     `new ${collectionType}(client, memberNode, (client, child) => ${childConverter(ctx, entryMember, false, false, genericEnv)}${keyCodecArguments})`
   );
 }
-function enumKeyCodecArguments(enumId, enumName) {
-  return enumId === NEO_CELL_PATTERN_EXCLUDING_ENUM_ID ? ", id => NeoCellPatternStorage.ReadExcluding(new[] { id }), key => NeoCellPatternStorage.ExcludingIds(key)[0]" : `, ${enumParser(enumName)}, key => key.optionId`;
+function enumKeyCodecArguments(ctx, enumId) {
+  return enumId === NEO_CELL_PATTERN_EXCLUDING_ENUM_ID ? ", id => NeoCellPatternStorage.ReadExcluding(new[] { id }), key => NeoCellPatternStorage.ExcludingIds(key)[0]" : `, ${enumParser(ctx, enumId)}, key => key.OptionId()`;
 }
 function dictionaryKeyCodecArguments(ctx, member) {
   if (!isEnumKeyedDictionaryMember(member)) return "";
-  const keyEnumName = ctx.enumNames.get(member.keyEnumId);
-  if (keyEnumName === void 0) return "";
-  return enumKeyCodecArguments(member.keyEnumId, keyEnumName);
+  if (!ctx.enumNames.has(member.keyEnumId)) return "";
+  return enumKeyCodecArguments(ctx, member.keyEnumId);
 }
 function serializeItemExpression(ctx, member, valueExpression) {
   if (member === null) return valueExpression;
@@ -152855,7 +153178,7 @@ function serializeItemExpression(ctx, member, valueExpression) {
   if (isMemberEnumBase(member)) {
     if (member.enumId === NEO_CELL_PATTERN_EXCLUDING_ENUM_ID)
       return `NeoGeneratedTypesSupport.Value(NeoCellPatternStorage.${isMultiSelectionMember(member) ? "ExcludingListIds" : "OptionalExcludingIds"}(${valueExpression}))`;
-    const rawExpression = isMultiSelectionMember(member) ? `${ctx.enumNames.get(member.enumId) ?? "NeoEnum"}.ToOptionIds(${valueExpression})` : `${valueExpression} is null ? null : new[] { ${valueExpression}.optionId }`;
+    const rawExpression = isMultiSelectionMember(member) ? `${enumOptionsName(ctx, member.enumId)}.ToOptionIds(${valueExpression})` : `${valueExpression} is ${ctx.enumNames.get(member.enumId) ?? "NeoEnum"} enumOption ? new[] { enumOption.OptionId() } : null`;
     return `NeoGeneratedTypesSupport.Value(${rawExpression})`;
   }
   if (isMemberLookupBase(member)) {
@@ -153044,8 +153367,8 @@ function childConverter(ctx, member, saved = false, branchOnReadOnly = false, ge
   if (isMemberEnumBase(member)) {
     if (member.enumId === NEO_CELL_PATTERN_EXCLUDING_ENUM_ID)
       return `NeoCellPatternStorage.${isMultiSelectionMember(member) ? "ReadExcludingList" : isRequiredMember2(member) ? "ReadExcluding" : "ReadOptionalExcluding"}(((NeoMemberEnum)child).Selected())`;
-    const enumName = ctx.enumNames.get(member.enumId) ?? "string";
-    return isMultiSelectionMember(member) ? `NeoGeneratedTypesSupport.ReadEnumList(((NeoMemberEnum)child).Selected(), ${enumParser(enumName)})` : isRequiredMember2(member) ? `NeoGeneratedTypesSupport.ReadEnumSingle(((NeoMemberEnum)child).Selected(), ${enumParser(enumName)}) ?? throw new InvalidOperationException("Required enum '${escapeCSharpString(member.name)}' has no selected option.")` : `NeoGeneratedTypesSupport.ReadEnumSingle(((NeoMemberEnum)child).Selected(), ${enumParser(enumName)})`;
+    const parser = enumParser(ctx, member.enumId);
+    return isMultiSelectionMember(member) ? `NeoGeneratedTypesSupport.ReadEnumList(((NeoMemberEnum)child).Selected(), ${parser})` : isRequiredMember2(member) ? `NeoGeneratedTypesSupport.ReadEnumSingle(((NeoMemberEnum)child).Selected(), ${parser}) ?? throw new InvalidOperationException("Required enum '${escapeCSharpString(member.name)}' has no selected option.")` : `NeoGeneratedTypesSupport.ReadEnumSingle(((NeoMemberEnum)child).Selected(), ${parser})`;
   }
   if (isMemberLookupBase(member)) return "((NeoMemberLookup)child).Selected()";
   if (isMemberDialogueLookupBase(member))
@@ -153099,8 +153422,8 @@ function nsGetterChildConverter(ctx, returnTypeInfo, saved, genericEnv) {
     case 8 /* Enum */: {
       if (returnTypeInfo.enumId === NEO_CELL_PATTERN_EXCLUDING_ENUM_ID)
         return `NeoCellPatternStorage.${returnTypeInfo.required ? "ReadExcluding" : "ReadOptionalExcluding"}(${valueExpression})`;
-      const enumName = ctx.enumNames.get(returnTypeInfo.enumId) ?? "string";
-      return `NeoGeneratedTypesSupport.ReadEnumSingle(${valueExpression}, ${enumParser(enumName)})`;
+      const readExpression2 = `NeoGeneratedTypesSupport.ReadEnumSingle(${valueExpression}, ${enumParser(ctx, returnTypeInfo.enumId)})`;
+      return returnTypeInfo.required ? `${readExpression2} ?? throw new InvalidOperationException("NSProperty returned null for a required enum value.")` : readExpression2;
     }
     case 18 /* DialogueLookup */: {
       const dialogueIds = `NeoGeneratedTypesSupport.ToStringArray(${valueExpression})`;
@@ -153167,7 +153490,7 @@ function escapeCSharpString(value) {
     (character) => CSHARP_STRING_ESCAPES.get(character) ?? `\\u${character.charCodeAt(0).toString(16).padStart(4, "0")}`
   );
 }
-var NEO_MEMORY_SCHEMA_KEYS, NEO_MEMORY_CLASS_NAMES, GENERATED_ENUM_CLASS_MEMBER_NAMES, CHILDREN_SCHEMA_KEY, TILE_LAYER_LINK_INTERFACE, OBJECT_LAYER_LINK_INTERFACE, OBJECT_SPAWN_HOOKS_INTERFACE, TILE_LAYER_RENDER_TARGET_PROVIDER_INTERFACE, SMART_TILE_SOURCE_INTERFACE, SMART_TILE_INTERFACE, SMART_TILE_RULE_INTERFACE, SMART_TILE_NEIGHBOR_INTERFACE, WORLD_OBJECT_VALUE_INTERFACE, OBJECT_COMPOSITION_SOURCE_INTERFACE, COLLIDER_SOURCE_INTERFACE, SORTING_GROUP_SOURCE_INTERFACE, COLLIDER_INTERFACE, SORTING_GROUP_INTERFACE, SPRITE_OBJECT_VALUE_INTERFACE, SORTING_GROUP_SOURCE_MEMBER_NAME, OBJECT_BASE_NAME_SCHEMA_KEY, OBJECT_BASE_POSITION_SCHEMA_KEY, OBJECT_BASE_SIZE_SCHEMA_KEY, SPRITE_OBJECT_SPRITE_SCHEMA_KEY, SPRITE_OBJECT_FLIP_X_SCHEMA_KEY, SPRITE_OBJECT_FLIP_Y_SCHEMA_KEY, SPRITE_OBJECT_MASK_INTERACTION_SCHEMA_KEY, SPRITE_OBJECT_SORTING_ORDER_SCHEMA_KEY, TILE_CELL_SCHEMA_KEY, EMPTY_RUNTIME_CONTRACT_PLAN, SMART_TILE_CONTRACT_WORLD_KINDS, WORLD_OBJECT_CONTRACT_WORLD_KINDS, SMART_TILE_NEIGHBOR_TILE_RELATION_EXPRESSION, REQUIRED_STRING_CONTRACT_FIELD, REQUIRED_BOOL_CONTRACT_FIELD, OPTIONAL_BOOL_CONTRACT_FIELD, OPTIONAL_INT_CONTRACT_FIELD, REQUIRED_FLOAT_CONTRACT_FIELD, REQUIRED_SPRITE_CONTRACT_FIELD, REQUIRED_VECTOR2_CONTRACT_FIELD, OPTIONAL_VECTOR2_CONTRACT_FIELD, REQUIRED_VECTOR2_INT_CONTRACT_FIELD, REQUIRED_VECTOR3_CONTRACT_FIELD, VARIANTS_SCOPE_NAME, BASE_VARIANT_NAME, VARIANT_APPLY_METHOD_NAME, VARIANT_FOLDER_SEPARATOR, CSHARP_STRING_ESCAPES, UNRESOLVED_VARIANT_TARGET;
+var NEO_MEMORY_SCHEMA_KEYS, NEO_MEMORY_CLASS_NAMES, CHILDREN_SCHEMA_KEY, TILE_LAYER_LINK_INTERFACE, OBJECT_LAYER_LINK_INTERFACE, OBJECT_SPAWN_HOOKS_INTERFACE, TILE_LAYER_RENDER_TARGET_PROVIDER_INTERFACE, SMART_TILE_SOURCE_INTERFACE, SMART_TILE_INTERFACE, SMART_TILE_RULE_INTERFACE, SMART_TILE_NEIGHBOR_INTERFACE, WORLD_OBJECT_VALUE_INTERFACE, OBJECT_COMPOSITION_SOURCE_INTERFACE, COLLIDER_SOURCE_INTERFACE, SORTING_GROUP_SOURCE_INTERFACE, COLLIDER_INTERFACE, SORTING_GROUP_INTERFACE, SPRITE_OBJECT_VALUE_INTERFACE, SORTING_GROUP_SOURCE_MEMBER_NAME, OBJECT_BASE_NAME_SCHEMA_KEY, OBJECT_BASE_POSITION_SCHEMA_KEY, OBJECT_BASE_SIZE_SCHEMA_KEY, SPRITE_OBJECT_SPRITE_SCHEMA_KEY, SPRITE_OBJECT_FLIP_X_SCHEMA_KEY, SPRITE_OBJECT_FLIP_Y_SCHEMA_KEY, SPRITE_OBJECT_MASK_INTERACTION_SCHEMA_KEY, SPRITE_OBJECT_SORTING_ORDER_SCHEMA_KEY, TILE_CELL_SCHEMA_KEY, EMPTY_RUNTIME_CONTRACT_PLAN, SMART_TILE_CONTRACT_WORLD_KINDS, WORLD_OBJECT_CONTRACT_WORLD_KINDS, SMART_TILE_NEIGHBOR_TILE_RELATION_EXPRESSION, REQUIRED_STRING_CONTRACT_FIELD, REQUIRED_BOOL_CONTRACT_FIELD, OPTIONAL_BOOL_CONTRACT_FIELD, OPTIONAL_INT_CONTRACT_FIELD, REQUIRED_FLOAT_CONTRACT_FIELD, REQUIRED_SPRITE_CONTRACT_FIELD, REQUIRED_VECTOR2_CONTRACT_FIELD, OPTIONAL_VECTOR2_CONTRACT_FIELD, REQUIRED_VECTOR2_INT_CONTRACT_FIELD, REQUIRED_VECTOR3_CONTRACT_FIELD, VARIANTS_SCOPE_NAME, BASE_VARIANT_NAME, VARIANT_APPLY_METHOD_NAME, VARIANT_FOLDER_SEPARATOR, CSHARP_STRING_ESCAPES, UNRESOLVED_VARIANT_TARGET;
 var init_generate_unity_classes = __esm({
   "../src/models/exports/unity-codegen/generate-unity-classes.ts"() {
     "use strict";
@@ -153213,24 +153536,6 @@ var init_generate_unity_classes = __esm({
       textNodeMemory: "NeoTextNodeMemory",
       choiceLog: "NeoChoiceLog"
     };
-    GENERATED_ENUM_CLASS_MEMBER_NAMES = /* @__PURE__ */ new Set([
-      "values",
-      "optionId",
-      "Text",
-      "TextId",
-      "FromOptionId",
-      "ToOptionIds",
-      "IsKnown",
-      "TextIdForOptionId",
-      "TextForOptionId",
-      "ToString",
-      "Equals",
-      "GetHashCode",
-      "GetType",
-      "ReferenceEquals",
-      "MemberwiseClone",
-      "Finalize"
-    ]);
     CHILDREN_SCHEMA_KEY = "Children";
     TILE_LAYER_LINK_INTERFACE = "INeoTileLayerLinkValue";
     OBJECT_LAYER_LINK_INTERFACE = "INeoObjectLayerLinkValue";
@@ -156488,7 +156793,7 @@ var UNITY_CODEGEN_REVISION;
 var init_unity_codegen_revision = __esm({
   "../src/models/exports/unity-codegen-revision.ts"() {
     "use strict";
-    UNITY_CODEGEN_REVISION = "03bfbde6bcc46538292d7c03998e5a684d7a0a0bff8959f9aeaa8a38d18753f5";
+    UNITY_CODEGEN_REVISION = "30d96d89e3d179ccf291e522834281f90dbd44b464cf51eea76aae87eed97e7e";
   }
 });
 
@@ -174074,6 +174379,7 @@ function selectedSpecPaths(workspace, selectors) {
   const normalizedSelectors = selectors.map(
     (selector) => selector.replaceAll("\\", "/").replace(/^\.\//u, "")
   );
+  const realRoot = realpathSync2(workspace.root);
   for (const selector of normalizedSelectors) {
     if (/[*?]/u.test(selector)) continue;
     if (isAbsolute3(selector)) {
@@ -174090,7 +174396,7 @@ function selectedSpecPaths(workspace, selectors) {
     }
     if (!existsSync19(absolute)) continue;
     const real = realpathSync2(absolute);
-    const realRelative = relative9(workspace.root, real);
+    const realRelative = relative9(realRoot, real);
     if (realRelative === ".." || realRelative.startsWith(`..${sep9}`)) {
       throw new Error(
         `Spec selector ${JSON.stringify(selector)} resolves outside the workspace through a symlink.`
@@ -182175,7 +182481,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.70.3");
+    console.log("0.70.5");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {