numbl 0.4.9 → 0.4.11

package/dist-browser/numbl-core/interpreter/interpreter.d.ts

@@ -180,6 +180,8 @@ export declare class Interpreter {
     }>, args: unknown[], nargout: number) => unknown;
     instantiateClass: (className: string, args: unknown[], nargout: number) => unknown;
     interpretConstructor: (classInfo: ClassInfo, args: unknown[], nargout: number) => unknown;
+    interpretEnumMember: (className: string, memberName: string) => RuntimeValue | null;
+    convertToEnum: (className: string, classInfo: ClassInfo, args: unknown[]) => RuntimeValue;
     callUserFunction: (fn: FunctionDef, args: unknown[], nargout: number, narginOverride?: number) => unknown;
     callNestedFunction: (fn: FunctionDef, parentEnv: Environment, args: unknown[], nargout: number) => unknown;
     withFileContext: <T>(file: string, className: string | undefined, methodName: string | undefined, fn: () => T) => T;

package/dist-browser/numbl-core/interpreter/interpreterFunctions.d.ts

@@ -3,6 +3,7 @@
  * Augments the Interpreter class via prototype assignment.
  */
 import type { Expr } from "../parser/types.js";
+import type { RuntimeValue } from "../runtime/types.js";
 import { type ResolvedTarget } from "../functionResolve.js";
 import type { ClassInfo } from "../lowering/classInfo.js";
 import { Environment, type FunctionDef } from "./types.js";
@@ -30,6 +31,13 @@ export declare function interpretClassMethod(this: Interpreter, target: Extract<
 export declare function interpretPrivateFunction(this: Interpreter, target: Extract<ResolvedTarget, {
     kind: "privateFunction";
 }>, args: unknown[], nargout: number): unknown;
+/** Resolve `ClassName.MemberName` to an enumeration-member instance. Returns
+ *  null when `className` is not an enumeration or has no such member. */
+export declare function interpretEnumMember(this: Interpreter, className: string, memberName: string): RuntimeValue | null;
+/** Enumeration constructor-as-converter: `ClassName(x)` for an enumeration
+ *  with no explicit constructor. Converts x — a member, a numeric value, a
+ *  char/string member name, or an array thereof — to member(s). */
+export declare function convertToEnum(this: Interpreter, className: string, classInfo: ClassInfo, args: unknown[]): RuntimeValue;
 export declare function instantiateClass(this: Interpreter, className: string, args: unknown[], nargout: number): unknown;
 export declare function interpretConstructor(this: Interpreter, classInfo: ClassInfo, args: unknown[], nargout: number): unknown;
 export declare function callUserFunction(this: Interpreter, fn: FunctionDef, args: unknown[], nargout: number, narginOverride?: number): unknown;

package/dist-browser/numbl-core/lowering/classInfo.d.ts

@@ -18,6 +18,12 @@ export interface ClassInfo {
     methodNames: Set<string>;
     staticMethodNames: Set<string>;
     constructorName: string | null;
+    /** Enumeration members in declaration order (name + constructor-arg
+     *  exprs), or null when the class is not an enumeration. */
+    enumMembers: {
+        name: string;
+        args: Expr[];
+    }[] | null;
     ast: (Stmt & {
         type: "ClassDef";
     }) | null;

package/dist-browser/numbl-core/parser/ClassParser.d.ts

@@ -7,6 +7,11 @@ export declare class ClassParser extends FunctionParser {
     parseImport(): Stmt;
     parseClassDef(): Stmt;
     private parseNameBlock;
+    /** Parse an `enumeration ... end` member list. Each member is a bare
+     *  identifier optionally followed by a parenthesized argument list
+     *  (`quad (0)`, `Error (1, 0, 0)`). Members are separated by `;`/`,`/
+     *  newline. The args are evaluated later (at member construction). */
+    private parseEnumerationBlock;
     private parsePropertiesNamesBlock;
     /** Consume a balanced `open ... close` run (handling nesting). Assumes the
      *  next token is `open`; no-op otherwise. */

package/dist-browser/numbl-core/parser/types.d.ts

@@ -194,7 +194,13 @@ export type ClassMember = {
 } | {
     type: "Enumeration";
     attributes: Attr[];
-    names: string[];
+    /** Enumeration members in declaration order. Each has a name and an
+     *  optional argument list (`quad (0)` → args `[0]`). Args are passed
+     *  to the constructor / first superclass to build the member value. */
+    members: {
+        name: string;
+        args: Expr[];
+    }[];
 } | {
     type: "Arguments";
     attributes: Attr[];

package/dist-browser/numbl-core/runtime/runtimeEnum.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Enumeration-class value semantics.
+ *
+ * An enumeration member is represented as a `RuntimeClassInstance` whose
+ * `_enumMember` field holds the member name and whose `_builtinData` holds the
+ * underlying (superclass) numeric value — e.g. for `classdef patchtype < uint32`
+ * the member `tri (1)` is stored with `_enumMember = "tri"`, `_builtinData = 1`.
+ *
+ * MATLAB comparison rules (verified against R2025b):
+ *   - enum == enum      → compare underlying values (inherited from the numeric
+ *                         superclass); falls back to name equality for plain
+ *                         enumerations that carry no superclass value.
+ *   - enum == numeric   → compare underlying value to the number.
+ *   - enum == char/str  → compare the member NAME to the text (a non-matching
+ *                         name yields false, never an error), NOT an
+ *                         element-wise char-code comparison.
+ * Comparisons are element-wise with scalar broadcasting; arrays of members
+ * produce a logical array the size of the member array.
+ */
+import { type RuntimeValue, type RuntimeClassInstance } from "./types.js";
+/** True if `v` is a single enumeration-member instance. */
+export declare function isEnumInstance(v: RuntimeValue): v is RuntimeClassInstance;
+/** True if `v` is an enumeration member or an array of enumeration members. */
+export declare function isEnumValue(v: RuntimeValue): boolean;
+/** Compare one enumeration member `e` against a scalar operand `other`
+ *  (another member, a number, or char/string text). */
+export declare function enumScalarEquals(e: RuntimeClassInstance, other: RuntimeValue): boolean;
+/**
+ * Element-wise `==` / `~=` for enumeration operands. Returns a logical result
+ * (a boolean for scalars, a logical tensor for arrays), or null if the op is
+ * not equality/inequality or neither operand is an enumeration value.
+ */
+export declare function enumEqualityOp(op: string, a: RuntimeValue, b: RuntimeValue): RuntimeValue | null;

package/dist-browser/numbl-core/runtime/types.d.ts

@@ -123,7 +123,11 @@ export declare class RuntimeClassInstance extends Refcounted {
     /** For classes that inherit from built-in types (e.g. classdef Foo < double),
      *  stores the underlying built-in data. */
     _builtinData: RuntimeValue | undefined;
-    constructor(className: string, fields: Map<string, RuntimeValue>, isHandleClass: boolean, _builtinData?: RuntimeValue);
+    /** For enumeration-class members: the member name (e.g. "tri"). When set,
+     *  this instance is an enumeration member and `_builtinData` holds its
+     *  underlying (superclass) value. Drives ==/~=, switch, and char coercion. */
+    _enumMember: string | undefined;
+    constructor(className: string, fields: Map<string, RuntimeValue>, isHandleClass: boolean, _builtinData?: RuntimeValue, _enumMember?: string);
     /** Set/replace a field value (handle-class in-place mutation), with
      *  proper decref-old / incref-new bookkeeping. Used for handle-class
      *  field assigns; value-class field assigns construct a new instance. */

package/dist-browser/numbl-core/version.d.ts

@@ -1,2 +1,2 @@
 /** Numbl version, used for JIT disk cache invalidation. */
-export declare const NUMBL_VERSION = "0.4.9";
+export declare const NUMBL_VERSION = "0.4.11";

package/dist-cli/cli.js

@@ -848,12 +848,17 @@ var RuntimeClassInstance = class extends Refcounted {
   /** For classes that inherit from built-in types (e.g. classdef Foo < double),
    *  stores the underlying built-in data. */
   _builtinData;
-  constructor(className, fields, isHandleClass2, _builtinData) {
+  /** For enumeration-class members: the member name (e.g. "tri"). When set,
+   *  this instance is an enumeration member and `_builtinData` holds its
+   *  underlying (superclass) value. Drives ==/~=, switch, and char coercion. */
+  _enumMember;
+  constructor(className, fields, isHandleClass2, _builtinData, _enumMember) {
     super();
     this.className = className;
     this.fields = fields;
     this.isHandleClass = isHandleClass2;
     this._builtinData = _builtinData;
+    this._enumMember = _enumMember;
     for (const v of fields.values()) incref(v);
     if (_builtinData !== void 0) incref(_builtinData);
   }
@@ -21670,6 +21675,10 @@ var valuesAreEqual = (a, b) => {
       return a === b;
     }
     case "class_instance": {
+      const bi = b;
+      if (a._enumMember !== void 0 || bi._enumMember !== void 0) {
+        return a._enumMember === bi._enumMember && a.className === bi.className;
+      }
       return a === b;
     }
     case "complex_number": {
@@ -22138,6 +22147,19 @@ function assignSlice(base, rowIndices, colIndices, rhs, curRows) {
   if (isRuntimeTensor(rhs)) {
     const nR = rowIndices.length;
     const nC = colIndices.length;
+    if (rhs.data.length === 1) {
+      const re = rhs.data[0];
+      const im = rhs.imag ? rhs.imag[0] : 0;
+      if (im !== 0 || base.imag) ensureImag(base);
+      for (const r of rowIndices) {
+        for (const c of colIndices) {
+          const li = colMajorIndex(r, c, curRows);
+          base.data[li] = re;
+          if (base.imag) base.imag[li] = im;
+        }
+      }
+      return;
+    }
     const [rhsRows, rhsCols] = tensorSize2D(rhs);
     const shapeMatches = rhsRows === nR && rhsCols === nC;
     const sliceIsVector = nR === 1 || nC === 1;
@@ -29191,6 +29213,15 @@ function inferJitType(value) {
       fields
     };
   }
+  if (isRuntimeClassInstanceArray(value)) {
+    const arr = value;
+    return {
+      kind: "class_instance",
+      className: arr.className,
+      isHandleClass: false,
+      fields: {}
+    };
+  }
   if (typeof value === "object" && value !== null && value.kind === "function") {
     return { kind: "function_handle" };
   }
@@ -32946,11 +32977,15 @@ var ClassParser = class extends FunctionParser {
       } else if (tok === 20 /* Enumeration */) {
         this.pos++;
         const attrs = this.parseOptionalAttrList();
-        const names = this.parseNameBlock();
+        const enumMembers = this.parseEnumerationBlock();
         if (!this.consume(15 /* End */)) {
           throw this.error("expected 'end' after enumeration");
         }
-        members.push({ type: "Enumeration", attributes: attrs, names });
+        members.push({
+          type: "Enumeration",
+          attributes: attrs,
+          members: enumMembers
+        });
       } else if (tok === 21 /* Arguments */) {
         this.pos++;
         const attrs = this.parseOptionalAttrList();
@@ -32991,6 +33026,38 @@ var ClassParser = class extends FunctionParser {
     }
     return names;
   }
+  /** Parse an `enumeration ... end` member list. Each member is a bare
+   *  identifier optionally followed by a parenthesized argument list
+   *  (`quad (0)`, `Error (1, 0, 0)`). Members are separated by `;`/`,`/
+   *  newline. The args are evaluated later (at member construction). */
+  parseEnumerationBlock() {
+    const members = [];
+    while (this.peekToken() !== void 0) {
+      if (this.peekToken() === 15 /* End */) break;
+      if (this.consume(49 /* Semicolon */) || this.consume(47 /* Comma */) || this.consume(68 /* Newline */)) {
+        continue;
+      }
+      if (this.peekToken() !== 4 /* Ident */) break;
+      const name = this.expectIdent();
+      const args = [];
+      if (this.consume(50 /* LParen */)) {
+        if (this.peekToken() !== 51 /* RParen */) {
+          args.push(this.parseExpr());
+          while (this.consume(47 /* Comma */)) {
+            args.push(this.parseExpr());
+          }
+        }
+        if (!this.consume(51 /* RParen */)) {
+          throw this.errorWithExpected(
+            "expected ')' after enumeration member arguments",
+            ")"
+          );
+        }
+      }
+      members.push({ name, args });
+    }
+    return members;
+  }
   parsePropertiesNamesBlock() {
     const props = [];
     while (this.peekToken() !== void 0) {
@@ -33832,6 +33899,96 @@ function getConstant(name) {
 var COLON_SENTINEL = /* @__PURE__ */ Symbol("COLON");
 var END_SENTINEL = /* @__PURE__ */ Symbol("END");
 
+// src/numbl-core/runtime/runtimeEnum.ts
+function isEnumInstance(v) {
+  return isRuntimeClassInstance(v) && v._enumMember !== void 0;
+}
+function isEnumValue(v) {
+  if (isEnumInstance(v)) return true;
+  if (isRuntimeClassInstanceArray(v))
+    return v.elements.some((e) => e._enumMember !== void 0);
+  return false;
+}
+function asText(v) {
+  if (isRuntimeChar(v)) return v.value;
+  if (isRuntimeString(v)) return v;
+  return null;
+}
+function enumScalarEquals(e, other) {
+  const text = asText(other);
+  if (text !== null) return e._enumMember === text;
+  if (isEnumInstance(other)) {
+    if (e._builtinData !== void 0 && other._builtinData !== void 0) {
+      return toNumber(e._builtinData) === toNumber(other._builtinData);
+    }
+    return e._enumMember === other._enumMember;
+  }
+  if (e._builtinData !== void 0) {
+    if (isRuntimeNumber(other)) return toNumber(e._builtinData) === other;
+    if (isRuntimeLogical(other))
+      return toNumber(e._builtinData) === (other ? 1 : 0);
+  }
+  return false;
+}
+function decompose(v) {
+  if (isEnumInstance(v)) return { elems: [v], shape: [1, 1] };
+  if (isRuntimeClassInstanceArray(v))
+    return { elems: [...v.elements], shape: v.shape };
+  if (isRuntimeChar(v)) return { elems: [v], shape: [1, 1] };
+  if (isRuntimeString(v)) return { elems: [v], shape: [1, 1] };
+  if (isRuntimeStringArray(v))
+    return { elems: v.data.map((s) => s), shape: v.shape };
+  if (isRuntimeNumber(v) || isRuntimeLogical(v))
+    return { elems: [v], shape: [1, 1] };
+  if (isRuntimeTensor(v)) {
+    const shape = [v.shape[0] ?? 0, v.shape[1] ?? 1];
+    return { elems: Array.from(v.data, (x) => x), shape };
+  }
+  return null;
+}
+function elementEquals(x, y) {
+  if (isEnumInstance(x)) return enumScalarEquals(x, y);
+  if (isEnumInstance(y)) return enumScalarEquals(y, x);
+  return false;
+}
+function enumEqualityOp(op, a, b) {
+  if (op !== "Equal" /* Equal */ && op !== "NotEqual" /* NotEqual */)
+    return null;
+  if (!isEnumValue(a) && !isEnumValue(b)) return null;
+  const oa = decompose(a);
+  const ob = decompose(b);
+  if (!oa || !ob) return null;
+  const na = oa.elems.length;
+  const nb = ob.elems.length;
+  let n;
+  let shape;
+  if (na === nb) {
+    n = na;
+    shape = oa.shape;
+  } else if (na === 1) {
+    n = nb;
+    shape = ob.shape;
+  } else if (nb === 1) {
+    n = na;
+    shape = oa.shape;
+  } else {
+    throw new RuntimeError("Array dimensions must match for comparison");
+  }
+  const negate = op === "NotEqual" /* NotEqual */;
+  const out = new Float64Array(n);
+  for (let i = 0; i < n; i++) {
+    const eq2 = elementEquals(
+      oa.elems[na === 1 ? 0 : i],
+      ob.elems[nb === 1 ? 0 : i]
+    );
+    out[i] = (negate ? !eq2 : eq2) ? 1 : 0;
+  }
+  if (n === 1) return RTV.logical(out[0] === 1);
+  const t = RTV.tensor(out, [shape[0], shape[1]]);
+  t._isLogical = true;
+  return t;
+}
+
 // src/numbl-core/runtime/runtimeHelpers.ts
 function isDeferredRange(v) {
   return typeof v === "object" && v !== null && v["_deferredRange"] === true;
@@ -33856,6 +34013,8 @@ function ensureRuntimeValue(v) {
   return v;
 }
 function switchValuesMatch(a, b) {
+  if (isEnumInstance(a)) return enumScalarEquals(a, b);
+  if (isEnumInstance(b)) return enumScalarEquals(b, a);
   if ((isRuntimeChar(a) || isRuntimeString(a)) && (isRuntimeChar(b) || isRuntimeString(b))) {
     return (typeof a === "string" ? a : a.value) === (typeof b === "string" ? b : b.value);
   }
@@ -37293,7 +37452,16 @@ function indexStore(rt, base, indices, rhs, skipSubsasgn = false) {
       }
       existing[k] = rhsInst;
       if (existing.length === 1) return existing[0];
-      return RTV.classInstanceArray(className, existing, [1, existing.length]);
+      const origShape = isRuntimeClassInstanceArray(mv) ? mv.shape : null;
+      let shape;
+      if (origShape && existing.length === origShape[0] * origShape[1]) {
+        shape = origShape;
+      } else if (origShape && origShape[1] === 1) {
+        shape = [existing.length, 1];
+      } else {
+        shape = [1, existing.length];
+      }
+      return RTV.classInstanceArray(className, existing, shape);
     }
   }
   if (isRuntimeClassInstance(mv)) {
@@ -46532,6 +46700,8 @@ function sparseToDense2(S) {
   return RTV.tensor(data, [S.m, S.n], imag2);
 }
 function valuesEqualSimple(a, b) {
+  if (isEnumInstance(a)) return enumScalarEquals(a, b);
+  if (isEnumInstance(b)) return enumScalarEquals(b, a);
   {
     const aText = textValue(a);
     const bText = textValue(b);
@@ -54720,7 +54890,8 @@ function copyClassInstance(inst) {
     inst.className,
     new Map(inst.fields),
     inst.isHandleClass,
-    inst._builtinData
+    inst._builtinData,
+    inst._enumMember
   );
 }
 function repelemObjects(v, repArgs) {
@@ -57808,6 +57979,15 @@ defineBuiltin({
 });
 
 // src/numbl-core/interpreter/builtins/type-constructors.ts
+function classInstanceArrayNumeric(v) {
+  if (!isRuntimeClassInstanceArray(v)) return null;
+  const data = allocFloat64Array(v.elements.length);
+  for (let i = 0; i < v.elements.length; i++) {
+    const bd = v.elements[i]._builtinData;
+    data[i] = bd !== void 0 ? toNumber(bd) : NaN;
+  }
+  return RTV.tensor(data, [v.shape[0], v.shape[1]]);
+}
 function parseDoubleText(s) {
   const t = s.trim();
   if (t === "") return NaN;
@@ -57862,6 +58042,8 @@ defineBuiltin({
         if (isRuntimeClassInstance(v) && v._builtinData !== void 0) {
           return v._builtinData;
         }
+        const arr = classInstanceArrayNumeric(v);
+        if (arr) return arr;
         return RTV.num(toNumber(v));
       }
     }
@@ -57889,6 +58071,8 @@ function singleApply(v) {
   }
   if (isRuntimeClassInstance(v) && v._builtinData !== void 0)
     return singleApply(v._builtinData);
+  const arr = classInstanceArrayNumeric(v);
+  if (arr) return singleApply(arr);
   return RTV.num(Math.fround(toNumber(v)));
 }
 defineBuiltin({
@@ -57948,7 +58132,7 @@ for (const { name, min: min2, max: max2 } of INT_RANGES) {
         match: (argTypes) => {
           if (argTypes.length !== 1) return null;
           const a = argTypes[0];
-          if (a.kind === "number" || a.kind === "boolean" || a.kind === "char" || a.kind === "complex_or_number")
+          if (a.kind === "number" || a.kind === "boolean" || a.kind === "char" || a.kind === "complex_or_number" || a.kind === "class_instance")
             return [{ kind: "number" }];
           if (a.kind === "tensor")
             return [
@@ -57962,7 +58146,7 @@ for (const { name, min: min2, max: max2 } of INT_RANGES) {
           return null;
         },
         apply: (args) => {
-          const v = args[0];
+          const v = isRuntimeClassInstance(args[0]) && args[0]._builtinData !== void 0 ? args[0]._builtinData : classInstanceArrayNumeric(args[0]) ?? args[0];
           if (isRuntimeNumber(v))
             return RTV.num(saturateRoundToward(v, min2, max2));
           if (isRuntimeLogical(v)) return RTV.num(v ? 1 : 0);
@@ -58217,7 +58401,7 @@ defineBuiltin({
       match: (argTypes) => {
         if (argTypes.length !== 1) return null;
         const a = argTypes[0];
-        if (a.kind === "number" || a.kind === "boolean")
+        if (a.kind === "number" || a.kind === "boolean" || a.kind === "class_instance")
           return [{ kind: "boolean" }];
         if (a.kind === "tensor")
           return [
@@ -58232,7 +58416,7 @@ defineBuiltin({
         return null;
       },
       apply: (args) => {
-        const v = args[0];
+        const v = isRuntimeClassInstance(args[0]) && args[0]._builtinData !== void 0 ? args[0]._builtinData : classInstanceArrayNumeric(args[0]) ?? args[0];
         if (isRuntimeTensor(v)) {
           const result = allocFloat64Array(v.data.length);
           for (let i = 0; i < v.data.length; i++) {
@@ -63891,7 +64075,7 @@ function getSourceLine(getSource, file, line) {
 }
 
 // src/numbl-core/version.ts
-var NUMBL_VERSION = "0.4.9";
+var NUMBL_VERSION = "0.4.11";
 
 // src/cli-repl.ts
 import { createInterface } from "readline";
@@ -66402,6 +66586,8 @@ function evalBinary(expr) {
   const right = this.evalExpr(expr.right);
   const lv = ensureRuntimeValue(left);
   const rv = ensureRuntimeValue(right);
+  const enumResult = enumEqualityOp(expr.op, lv, rv);
+  if (enumResult !== null) return enumResult;
   if (isRuntimeClassInstance(lv) || isRuntimeClassInstance(rv)) {
     return this.rt.binop(expr.op, left, right);
   }
@@ -66506,6 +66692,8 @@ function evalMember(expr, nargout) {
       if (lastDot > 0) {
         const prefix = dottedName.slice(0, lastDot);
         const methodName = dottedName.slice(lastDot + 1);
+        const enumMember = this.interpretEnumMember(prefix, methodName);
+        if (enumMember !== null) return enumMember;
         if (this.functionIndex.classStaticMethods.get(prefix)?.has(methodName) || // Implicit static `ClassName.empty` (handled by interpretClassMethod)
         methodName === "empty" && this.functionIndex.workspaceClasses.has(prefix)) {
           const target = {
@@ -66965,6 +67153,7 @@ __export(interpreterFunctions_exports, {
   callNestedFunction: () => callNestedFunction,
   callUserFunction: () => callUserFunction,
   collectClassProperties: () => collectClassProperties,
+  convertToEnum: () => convertToEnum,
   declaredNargin: () => declaredNargin,
   evalInLocalScope: () => evalInLocalScope,
   findExternalMethod: () => findExternalMethod,
@@ -66976,6 +67165,7 @@ __export(interpreterFunctions_exports, {
   instantiateClass: () => instantiateClass,
   interpretClassMethod: () => interpretClassMethod,
   interpretConstructor: () => interpretConstructor,
+  interpretEnumMember: () => interpretEnumMember,
   interpretJsUserFunction: () => interpretJsUserFunction,
   interpretLocalFunction: () => interpretLocalFunction,
   interpretPrivateFunction: () => interpretPrivateFunction,
@@ -67805,11 +67995,95 @@ function interpretPrivateFunction(target, args, nargout) {
   }
   throw new RuntimeError(`Private function '${target.name}' not found`);
 }
+var NUMERIC_ENUM_SUPERS = /* @__PURE__ */ new Set([
+  "double",
+  "single",
+  "int8",
+  "int16",
+  "int32",
+  "int64",
+  "uint8",
+  "uint16",
+  "uint32",
+  "uint64",
+  "logical",
+  "char"
+]);
+function enumUnderlyingValue(interp, classInfo, argExprs) {
+  if (argExprs.length === 0) return void 0;
+  const first = ensureRuntimeValue(interp.evalExpr(argExprs[0]));
+  const sc = classInfo.superClass;
+  if (sc && NUMERIC_ENUM_SUPERS.has(sc)) {
+    return ensureRuntimeValue(interp.rt.callBuiltin(sc, 1, [first]));
+  }
+  return first;
+}
+function interpretEnumMember(className, memberName) {
+  const classInfo = this.ctx.getClassInfo(className);
+  if (!classInfo || !classInfo.enumMembers) return null;
+  const memberDef = classInfo.enumMembers.find((m) => m.name === memberName);
+  if (!memberDef) return null;
+  const value = enumUnderlyingValue(this, classInfo, memberDef.args);
+  return new RuntimeClassInstance(
+    className,
+    /* @__PURE__ */ new Map(),
+    false,
+    value,
+    memberName
+  );
+}
+function convertToEnum(className, classInfo, args) {
+  if (args.length === 0) {
+    throw new RuntimeError(
+      `${className}: enumeration requires an argument to construct`
+    );
+  }
+  const val = ensureRuntimeValue(args[0]);
+  if (isRuntimeClassInstance(val) && val._enumMember !== void 0) return val;
+  if (isRuntimeClassInstanceArray(val)) return val;
+  const members = classInfo.enumMembers.map((m) => ({
+    name: m.name,
+    value: enumUnderlyingValue(this, classInfo, m.args)
+  }));
+  const makeMember = (name, value) => new RuntimeClassInstance(className, /* @__PURE__ */ new Map(), false, value, name);
+  const fromName = (text) => {
+    const m = members.find((mm) => mm.name === text);
+    if (!m)
+      throw new RuntimeError(
+        `'${text}' is not a valid member of enumeration '${className}'`
+      );
+    return makeMember(m.name, m.value);
+  };
+  const fromNumber = (num) => {
+    const m = members.find(
+      (mm) => mm.value !== void 0 && toNumber(mm.value) === num
+    );
+    if (!m)
+      throw new RuntimeError(
+        `${num} is not a valid underlying value for enumeration '${className}'`
+      );
+    return makeMember(m.name, m.value);
+  };
+  if (isRuntimeChar(val)) return fromName(val.value);
+  if (isRuntimeString(val)) return fromName(val);
+  if (isRuntimeNumber(val)) return fromNumber(val);
+  if (isRuntimeLogical(val)) return fromNumber(val ? 1 : 0);
+  if (isRuntimeTensor(val)) {
+    const elems = Array.from(val.data, (x) => fromNumber(x));
+    if (elems.length === 1) return elems[0];
+    const shape = [val.shape[0] ?? 0, val.shape[1] ?? 1];
+    return RTV.classInstanceArray(className, elems, shape);
+  }
+  throw new RuntimeError(`Cannot convert value to enumeration '${className}'`);
+}
 function instantiateClass(className, args, nargout) {
   const classInfo = this.ctx.getClassInfo(className);
   if (!classInfo) {
     return this.rt.callClassMethod(className, className, nargout, args);
   }
+  if (classInfo.enumMembers && args.length > 0) {
+    return this.convertToEnum(className, classInfo, args);
+  }
   if (classInfo.isOldStyle) {
     const ctorName = classInfo.constructorName ?? className;
     const ctorFn = this.findExternalMethod(classInfo, ctorName);
@@ -68610,6 +68884,7 @@ function extractClassInfo(classDef, qualifiedName, fileName, source) {
   const methodNames = /* @__PURE__ */ new Set();
   const staticMethodNames = /* @__PURE__ */ new Set();
   let constructorName = null;
+  let enumMembers = null;
   const dotIdx = qualifiedName.lastIndexOf(".");
   const baseName = dotIdx >= 0 ? qualifiedName.slice(dotIdx + 1) : qualifiedName;
   for (const member of classDef.members) {
@@ -68651,6 +68926,8 @@ function extractClassInfo(classDef, qualifiedName, fileName, source) {
           }
         }
       }
+    } else if (member.type === "Enumeration") {
+      enumMembers = member.members.map((m) => ({ name: m.name, args: m.args }));
     }
   }
   const inferiorClasses = [];
@@ -68673,6 +68950,7 @@ function extractClassInfo(classDef, qualifiedName, fileName, source) {
     methodNames,
     staticMethodNames,
     constructorName,
+    enumMembers,
     inferiorClasses,
     ast: classDef,
     externalMethodFiles: /* @__PURE__ */ new Map()
@@ -68703,6 +68981,7 @@ function makeOldStyleClassInfo(qualifiedName, baseName, constructorFile, methodF
     methodNames,
     staticMethodNames: /* @__PURE__ */ new Set(),
     constructorName: baseName,
+    enumMembers: null,
     inferiorClasses: [],
     ast: null,
     isOldStyle: true,
@@ -94502,6 +94781,12 @@ function assertNoNonVoidBareExprStmts2(spec) {
 
 // src/numbl-core/jit/lowering/classDefs.ts
 function registerClassDef(s, file, externalMethods) {
+  if (s.members.some((m) => m.type === "Enumeration")) {
+    throw new UnsupportedConstruct(
+      `classdef '${s.name}' is an enumeration; enumeration classes are interpreter-only in the JIT`,
+      s.span
+    );
+  }
   if (s.classAttributes.length > 0) {
     throw new UnsupportedConstruct(
       `classdef '${s.name}' has class attributes; not supported in v1`,