Enum OpCode 

#[repr(u16)]
pub enum OpCode {
    PushConst = 0,
    PushNull = 1,
    Pop = 2,
    Dup = 3,
    Swap = 4,
    BitAnd = 23,
    BitOr = 24,
    BitShl = 25,
    BitShr = 26,
    BitNot = 27,
    BitXor = 28,
    GtInt = 38,
    GtNumber = 39,
    GtDecimal = 40,
    LtInt = 41,
    LtNumber = 42,
    LtDecimal = 43,
    GteInt = 44,
    GteNumber = 45,
    GteDecimal = 46,
    LteInt = 47,
    And = 48,
    Or = 49,
    Not = 50,
    AddInt = 51,
    AddNumber = 52,
    AddDecimal = 53,
    SubInt = 54,
    SubNumber = 55,
    SubDecimal = 56,
    MulInt = 57,
    MulNumber = 58,
    MulDecimal = 59,
    DivInt = 60,
    DivNumber = 61,
    DivDecimal = 62,
    ModInt = 63,
    Jump = 64,
    JumpIfFalse = 65,
    JumpIfTrue = 66,
    Call = 67,
    Return = 68,
    ReturnValue = 69,
    CallValue = 70,
    LoadLocal = 80,
    StoreLocal = 81,
    LoadModuleBinding = 82,
    StoreModuleBinding = 83,
    LoadClosure = 84,
    StoreClosure = 85,
    MakeClosure = 86,
    CloseUpvalue = 87,
    MakeRef = 88,
    DerefLoad = 89,
    DerefStore = 90,
    SetIndexRef = 91,
    MakeFieldRef = 94,
    MakeIndexRef = 95,
    NewArray = 96,
    NewObject = 97,
    GetProp = 98,
    SetProp = 99,
    Length = 100,
    ArrayPush = 101,
    ArrayPop = 102,
    MergeObject = 103,
    SetLocalIndex = 104,
    SetModuleBindingIndex = 105,
    ArrayPushLocal = 106,
    NewMatrix = 107,
    NewTypedArray = 108,
    LoopStart = 112,
    LoopEnd = 113,
    Break = 114,
    Continue = 115,
    IterNext = 116,
    IterDone = 117,
    ConvertToInt = 118,
    ConvertToNumber = 119,
    ConvertToString = 120,
    ConvertToBool = 121,
    ConvertToDecimal = 122,
    ConvertToChar = 123,
    TryConvertToInt = 124,
    TryConvertToNumber = 125,
    TryConvertToString = 126,
    TryConvertToBool = 127,
    TryConvertToDecimal = 128,
    TryConvertToChar = 129,
    CallMethod = 136,
    PushTimeframe = 137,
    PopTimeframe = 138,
    BuiltinCall = 144,
    TypeCheck = 145,
    Convert = 146,
    ModNumber = 147,
    ModDecimal = 148,
    PowInt = 149,
    PowNumber = 150,
    PowDecimal = 151,
    NegInt = 202,
    NegNumber = 203,
    NegDecimal = 204,
    LteNumber = 152,
    LteDecimal = 153,
    EqInt = 154,
    EqNumber = 155,
    NeqInt = 156,
    NeqNumber = 157,
    SetupTry = 160,
    PopHandler = 161,
    Throw = 162,
    TryUnwrap = 163,
    UnwrapOption = 164,
    ErrorContext = 165,
    IsOk = 166,
    IsErr = 167,
    UnwrapOk = 168,
    UnwrapErr = 169,
    SliceAccess = 176,
    NullCoalesce = 177,
    MakeRange = 178,
    AddTyped = 179,
    SubTyped = 180,
    MulTyped = 181,
    DivTyped = 182,
    ModTyped = 183,
    CmpTyped = 184,
    GetDataField = 192,
    GetDataRow = 193,
    GetFieldTyped = 208,
    SetFieldTyped = 209,
    NewTypedObject = 210,
    TypedMergeObject = 211,
    WrapTypeAnnotation = 212,
    Yield = 224,
    Suspend = 225,
    Resume = 226,
    Poll = 227,
    AwaitBar = 228,
    AwaitTick = 229,
    Await = 230,
    SpawnTask = 231,
    EmitAlert = 232,
    EmitEvent = 233,
    JoinInit = 234,
    JoinAwait = 235,
    CancelTask = 236,
    AsyncScopeEnter = 237,
    AsyncScopeExit = 238,
    LoadColF64 = 194,
    LoadColI64 = 195,
    LoadColBool = 196,
    LoadColStr = 197,
    BindSchema = 198,
    BoxTraitObject = 239,
    DynMethodCall = 199,
    DropCall = 200,
    DropCallAsync = 201,
    LoadLocalTrusted = 215,
    JumpIfFalseTrusted = 216,
    Nop = 240,
    Halt = 241,
    IsNull = 242,
    IntToNumber = 243,
    NumberToInt = 244,
    CallForeign = 245,
    StoreLocalTyped = 246,
    CastWidth = 247,
    StoreModuleBindingTyped = 248,
    NewTypedArrayF64 = 5,
    NewTypedArrayI64 = 6,
    NewTypedArrayI32 = 7,
    TypedArrayGetF64 = 8,
    TypedArrayGetI64 = 9,
    TypedArrayGetI32 = 10,
    TypedArraySetF64 = 11,
    TypedArrayPushF64 = 12,
    TypedArrayPushI64 = 13,
    TypedArrayLen = 14,
    NewTypedArrayBool = 15,
    TypedArrayGetBool = 71,
    TypedArrayPushI32 = 72,
    TypedArrayPushBool = 73,
    TypedArraySetI64 = 74,
    TypedArraySetI32 = 75,
    TypedArraySetBool = 76,
    NewTypedArrayI8 = 16,
    TypedArrayGetI8 = 17,
    TypedArrayPushI8 = 18,
    TypedArraySetI8 = 19,
    NewTypedArrayU8 = 20,
    TypedArrayGetU8 = 21,
    TypedArrayPushU8 = 22,
    TypedArraySetU8 = 32,
    NewTypedArrayI16 = 33,
    TypedArrayGetI16 = 34,
    TypedArrayPushI16 = 35,
    TypedArraySetI16 = 36,
    NewTypedArrayU16 = 37,
    TypedArrayGetU16 = 280,
    TypedArrayPushU16 = 281,
    TypedArraySetU16 = 282,
    NewTypedArrayU32 = 283,
    TypedArrayGetU32 = 284,
    TypedArrayPushU32 = 285,
    TypedArraySetU32 = 286,
    NewTypedArrayF32 = 419,
    TypedArrayGetF32 = 420,
    TypedArrayPushF32 = 421,
    TypedArraySetF32 = 422,
    NewTypedArrayChar = 423,
    TypedArrayGetChar = 424,
    TypedArrayPushChar = 425,
    TypedArraySetChar = 426,
    NewTypedArrayString = 427,
    TypedArrayGetString = 428,
    TypedArrayPushString = 429,
    TypedArraySetString = 430,
    NewTypedArrayDecimal = 431,
    TypedArrayGetDecimal = 432,
    TypedArrayPushDecimal = 433,
    TypedArraySetDecimal = 434,
    NewStringV2 = 435,
    NewDecimalV2 = 436,
    NewTypedArrayTypedObject = 437,
    TypedArrayGetTypedObject = 438,
    TypedArrayPushTypedObject = 439,
    TypedArraySetTypedObject = 440,
    NewTypedMapStringF64 = 205,
    NewTypedMapStringI64 = 206,
    NewTypedMapStringPtr = 207,
    NewTypedMapI64F64 = 213,
    NewTypedMapI64I64 = 214,
    NewTypedMapI64Ptr = 217,
    TypedMapStringF64Get = 218,
    TypedMapStringI64Get = 219,
    TypedMapStringPtrGet = 220,
    TypedMapI64F64Get = 221,
    TypedMapI64I64Get = 222,
    TypedMapI64PtrGet = 223,
    TypedMapStringF64Set = 77,
    TypedMapStringI64Set = 78,
    TypedMapStringPtrSet = 79,
    TypedMapI64F64Set = 109,
    TypedMapI64I64Set = 110,
    TypedMapI64PtrSet = 111,
    TypedMapStringF64Has = 142,
    TypedMapStringI64Has = 143,
    TypedMapStringPtrHas = 185,
    TypedMapI64F64Has = 186,
    TypedMapI64I64Has = 187,
    TypedMapI64PtrHas = 188,
    TypedMapStringF64Delete = 189,
    TypedMapStringI64Delete = 190,
    TypedMapStringPtrDelete = 191,
    TypedMapI64F64Delete = 249,
    TypedMapI64I64Delete = 250,
    TypedMapI64PtrDelete = 251,
    StringConcat = 252,
    ArrayConcat = 253,
    EqString = 254,
    EqDecimal = 255,
    GtString = 256,
    LtString = 257,
    GteString = 258,
    LteString = 259,
    LoadLocalMove = 260,
    LoadLocalClone = 261,
    StoreLocalDrop = 262,
    PromoteToOwned = 263,
    GetElemI64 = 264,
    GetElemF64 = 265,
    SetElemI64 = 266,
    SetElemF64 = 267,
    ArrayPushI64 = 268,
    ArrayPushF64 = 269,
    ArrayLenTyped = 270,
    MapGetStrI64 = 271,
    MapGetStrF64 = 272,
    MapSetStrI64 = 273,
    MapHasStr = 274,
    MapLenTyped = 275,
    StringLenTyped = 276,
    StringCharAt = 277,
    StringConcatTyped = 278,
    ReturnOwned = 279,
    LoadOwnedMutableCapture = 306,
    StoreOwnedMutableCapture = 307,
    LoadSharedCapture = 308,
    StoreSharedCapture = 309,
    LoadOwnedMutableCaptureI64 = 320,
    LoadOwnedMutableCaptureU64 = 321,
    LoadOwnedMutableCaptureF64 = 322,
    LoadOwnedMutableCaptureI32 = 323,
    LoadOwnedMutableCaptureU32 = 324,
    LoadOwnedMutableCaptureI16 = 325,
    LoadOwnedMutableCaptureU16 = 326,
    LoadOwnedMutableCaptureI8 = 327,
    LoadOwnedMutableCaptureU8 = 328,
    LoadOwnedMutableCaptureBool = 329,
    LoadOwnedMutableCapturePtr = 330,
    StoreOwnedMutableCaptureI64 = 331,
    StoreOwnedMutableCaptureU64 = 332,
    StoreOwnedMutableCaptureF64 = 333,
    StoreOwnedMutableCaptureI32 = 334,
    StoreOwnedMutableCaptureU32 = 335,
    StoreOwnedMutableCaptureI16 = 336,
    StoreOwnedMutableCaptureU16 = 337,
    StoreOwnedMutableCaptureI8 = 338,
    StoreOwnedMutableCaptureU8 = 339,
    StoreOwnedMutableCaptureBool = 340,
    StoreOwnedMutableCapturePtr = 341,
    LoadSharedCaptureI64 = 342,
    LoadSharedCaptureU64 = 343,
    LoadSharedCaptureF64 = 344,
    LoadSharedCaptureI32 = 345,
    LoadSharedCaptureU32 = 346,
    LoadSharedCaptureI16 = 347,
    LoadSharedCaptureU16 = 348,
    LoadSharedCaptureI8 = 349,
    LoadSharedCaptureU8 = 350,
    LoadSharedCaptureBool = 351,
    LoadSharedCapturePtr = 352,
    StoreSharedCaptureI64 = 353,
    StoreSharedCaptureU64 = 354,
    StoreSharedCaptureF64 = 355,
    StoreSharedCaptureI32 = 356,
    StoreSharedCaptureU32 = 357,
    StoreSharedCaptureI16 = 358,
    StoreSharedCaptureU16 = 359,
    StoreSharedCaptureI8 = 360,
    StoreSharedCaptureU8 = 361,
    StoreSharedCaptureBool = 362,
    StoreSharedCapturePtr = 363,
    LoadLocalI64 = 364,
    LoadLocalU64 = 365,
    LoadLocalF64 = 366,
    LoadLocalI32 = 367,
    LoadLocalU32 = 368,
    LoadLocalI16 = 369,
    LoadLocalU16 = 370,
    LoadLocalI8 = 371,
    LoadLocalU8 = 372,
    LoadLocalBool = 373,
    LoadLocalPtr = 374,
    StoreLocalI64 = 375,
    StoreLocalU64 = 376,
    StoreLocalF64 = 377,
    StoreLocalI32 = 378,
    StoreLocalU32 = 379,
    StoreLocalI16 = 380,
    StoreLocalU16 = 381,
    StoreLocalI8 = 382,
    StoreLocalU8 = 383,
    StoreLocalBool = 384,
    StoreLocalPtr = 385,
    LoadModuleBindingI64 = 386,
    LoadModuleBindingU64 = 387,
    LoadModuleBindingF64 = 388,
    LoadModuleBindingI32 = 389,
    LoadModuleBindingU32 = 390,
    LoadModuleBindingI16 = 391,
    LoadModuleBindingU16 = 392,
    LoadModuleBindingI8 = 393,
    LoadModuleBindingU8 = 394,
    LoadModuleBindingBool = 395,
    LoadModuleBindingPtr = 396,
    StoreModuleBindingI64 = 397,
    StoreModuleBindingU64 = 398,
    StoreModuleBindingF64 = 399,
    StoreModuleBindingI32 = 400,
    StoreModuleBindingU32 = 401,
    StoreModuleBindingI16 = 402,
    StoreModuleBindingU16 = 403,
    StoreModuleBindingI8 = 404,
    StoreModuleBindingU8 = 405,
    StoreModuleBindingBool = 406,
    StoreModuleBindingPtr = 407,
    ReturnValueI64 = 408,
    ReturnValueU64 = 409,
    ReturnValueF64 = 410,
    ReturnValueI32 = 411,
    ReturnValueU32 = 412,
    ReturnValueI16 = 413,
    ReturnValueU16 = 414,
    ReturnValueI8 = 415,
    ReturnValueU8 = 416,
    ReturnValueBool = 417,
    ReturnValuePtr = 418,
    AllocSharedLocal = 310,
    LoadSharedLocal = 311,
    StoreSharedLocal = 312,
    DropSharedLocal = 313,
    AllocSharedModuleBinding = 314,
    LoadSharedModuleBinding = 315,
    StoreSharedModuleBinding = 316,
    CallClosure = 291,
    CallFunctionIndirect = 292,
    MoveLocal = 293,
    CloneLocal = 294,
    DropLocal = 295,
    PromoteToShared = 296,
    FieldLoadF64 = 130,
    FieldLoadI64 = 131,
    FieldLoadI32 = 132,
    FieldLoadBool = 133,
    FieldLoadPtr = 134,
    FieldStoreF64 = 135,
    FieldStoreI64 = 139,
    FieldStoreI32 = 140,
    NewTypedStruct = 141,
    AddI32 = 29,
    SubI32 = 30,
    MulI32 = 31,
    DivI32 = 158,
    ModI32 = 159,
    EqI32 = 170,
    NeqI32 = 171,
    LtI32 = 172,
    GtI32 = 173,
    LteI32 = 174,
    GteI32 = 175,
    BitAndInt = 297,
    BitOrInt = 298,
    BitXorInt = 299,
    BitShlInt = 300,
    BitShrInt = 301,
    BitNotInt = 302,
    StringConcatInt = 303,
    StringConcatNumber = 304,
    StringConcatBool = 305,
}

Variants

PushConst = 0

Push a constant onto the stack

PushNull = 1

Push null onto the stack

Pop = 2

Pop value from stack

Dup = 3

Duplicate top of stack

Swap = 4

Swap top two values

BitAnd = 23

Bitwise AND

BitOr = 24

Bitwise OR

BitShl = 25

Bitwise shift left

BitShr = 26

Bitwise shift right

BitNot = 27

Bitwise NOT

BitXor = 28

Bitwise XOR

GtInt = 38

Greater than (int × int → bool)

GtNumber = 39

Greater than (f64 × f64 → bool)

GtDecimal = 40

Greater than (decimal × decimal → bool)

LtInt = 41

Less than (int × int → bool)

LtNumber = 42

Less than (f64 × f64 → bool)

LtDecimal = 43

Less than (decimal × decimal → bool)

GteInt = 44

Greater than or equal (int × int → bool)

GteNumber = 45

Greater than or equal (f64 × f64 → bool)

GteDecimal = 46

Greater than or equal (decimal × decimal → bool)

LteInt = 47

Less than or equal (int × int → bool)

And = 48

Logical AND

Or = 49

Logical OR

Not = 50

Logical NOT

AddInt = 51

Add (int × int → int)

AddNumber = 52

Add (f64 × f64 → f64)

AddDecimal = 53

Add (decimal × decimal → decimal)

SubInt = 54

Subtract (int × int → int)

SubNumber = 55

Subtract (f64 × f64 → f64)

SubDecimal = 56

Subtract (decimal × decimal → decimal)

MulInt = 57

Multiply (int × int → int)

MulNumber = 58

Multiply (f64 × f64 → f64)

MulDecimal = 59

Multiply (decimal × decimal → decimal)

DivInt = 60

Divide (int × int → int)

DivNumber = 61

Divide (f64 × f64 → f64)

DivDecimal = 62

Divide (decimal × decimal → decimal)

ModInt = 63

Modulo (int × int → int)

Jump = 64

Unconditional jump

JumpIfFalse = 65

Jump if false (pop condition)

JumpIfTrue = 66

Jump if true (pop condition)

Call = 67

Function call

Return = 68

Return from function

ReturnValue = 69

Return with value

CallValue = 70

Call a value (function/closure) from the stack

LoadLocal = 80

Load local variable

StoreLocal = 81

Store local variable

LoadModuleBinding = 82

Load module_binding variable

StoreModuleBinding = 83

Store module_binding variable

LoadClosure = 84

Load from closure upvalue

StoreClosure = 85

Store to closure upvalue

MakeClosure = 86

Create a closure with captured upvalues.

Operand encoding:

• Operand::Function(fid): non-escaping closure (stack-safe in JIT Phase E).
• Operand::ClosureAlloc { fid, escapes: true }: escaping closure — always heap-allocated via TypedClosureHeader (JIT Phase H2 path).
• Operand::ClosureAlloc { fid, escapes: false }: non-escaping closure (equivalent to Function(fid); supported for uniform operand readers).

Closure spec H5 merged the former MakeClosureHeap into this opcode. See docs/v2-closure-specialization.md §13 H5.

CloseUpvalue = 87

Close upvalue - moves stack local to heap when leaving scope

MakeRef = 88

Create a reference to a local variable’s stack slot

DerefLoad = 89

Load the value that a reference points to

DerefStore = 90

Store a value through a reference

SetIndexRef = 91

Set an index on the array that a reference points to (in-place mutation)

MakeFieldRef = 94

Create a projected typed-field reference from a base reference on the stack.

MakeIndexRef = 95

Create a projected index reference: pops [base_ref, index] and pushes a projected reference whose RefProjection::Index stores the index value.

NewArray = 96

Create new array

NewObject = 97

Create new object

GetProp = 98

Get property/index

SetProp = 99

Set property/index

Length = 100

Get array/object length

ArrayPush = 101

Push value to array

ArrayPop = 102

Pop value from array

MergeObject = 103

Merge object fields from stack into another object

SetLocalIndex = 104

Set index on a local array without loading/cloning through the stack

SetModuleBindingIndex = 105

Set index on a module_binding array without loading/cloning through the stack

ArrayPushLocal = 106

Push value to array stored in a local variable, mutating in-place

NewMatrix = 107

Create a new Matrix from rows*cols f64 values on the stack

NewTypedArray = 108

Create a typed array (IntArray/FloatArray/BoolArray) from N homogeneous elements Operand: Count(n) — number of elements to pop At runtime, inspects element types and packs into the appropriate typed array

LoopStart = 112

Start of loop (for break/continue)

LoopEnd = 113

End of loop

Break = 114

Break from loop

Continue = 115

Continue to next iteration

IterNext = 116

Iterator next: pops iterator + index, pushes next value

IterDone = 117

Check if iterator done: pops iterator + index, pushes bool

ConvertToInt = 118

Convert value to int (infallible, panics on failure)

ConvertToNumber = 119

Convert value to number (infallible, panics on failure)

ConvertToString = 120

Convert value to string (infallible, always succeeds)

ConvertToBool = 121

Convert value to bool (infallible, panics on failure)

ConvertToDecimal = 122

Convert value to decimal (infallible, panics on failure)

ConvertToChar = 123

Convert value to char (infallible, panics on failure)

TryConvertToInt = 124

Try convert value to int (fallible, pushes Result<int, AnyError>)

TryConvertToNumber = 125

Try convert value to number (fallible, pushes Result<number, AnyError>)

TryConvertToString = 126

Try convert value to string (fallible, pushes Result<string, AnyError>)

TryConvertToBool = 127

Try convert value to bool (fallible, pushes Result<bool, AnyError>)

TryConvertToDecimal = 128

Try convert value to decimal (fallible, pushes Result<decimal, AnyError>)

TryConvertToChar = 129

Try convert value to char (fallible, pushes Result<char, AnyError>)

CallMethod = 136

Call method on value (array.map(), string.len(), etc.)

PushTimeframe = 137

Push timeframe context

PopTimeframe = 138

Pop timeframe context

BuiltinCall = 144

Call built-in function

TypeCheck = 145

Type check

Convert = 146

Convert type

ModNumber = 147

Modulo (f64 × f64 → f64)

ModDecimal = 148

Modulo (decimal × decimal → decimal)

PowInt = 149

Power (int × int → int)

PowNumber = 150

Power (f64 × f64 → f64)

PowDecimal = 151

Power (decimal × decimal → decimal)

NegInt = 202

Negate int (i64 → i64)

NegNumber = 203

Negate number (f64 → f64)

NegDecimal = 204

Negate decimal

LteNumber = 152

Less than or equal (f64 × f64 → bool)

LteDecimal = 153

Less than or equal (decimal × decimal → bool)

EqInt = 154

Equal (int × int → bool)

EqNumber = 155

Equal (f64 × f64 → bool)

NeqInt = 156

Not equal (int × int → bool)

NeqNumber = 157

Not equal (f64 × f64 → bool)

SetupTry = 160

Set up try/catch block (operand: offset to catch handler)

PopHandler = 161

Pop exception handler (successful try block completion)

Throw = 162

Throw an exception (push error value first)

TryUnwrap = 163

Try operator: unified Result/Option propagation with early return on Err/None

UnwrapOption = 164

Unwrap Option: extract inner value from Some, panic on None

ErrorContext = 165

Add context to Result/Option failures and lift success into Result

IsOk = 166

Check whether Result is Ok(value)

IsErr = 167

Check whether Result is Err(error)

UnwrapOk = 168

Extract inner payload from Ok(value)

UnwrapErr = 169

Extract inner payload from Err(error)

SliceAccess = 176

Slice access (array[start:end])

NullCoalesce = 177

Null coalescing (a ?? b)

MakeRange = 178

Range constructor (start..end / start..=end). Pops 3 operands: (start, end, inclusive_flag); pushes one Range value. W15-range (ADR-006 §2.7.23 / Q24, 2026-05-10) — corrected pops from 2 to 3 (the compiler in expressions/misc.rs:362-369 emits 3 pushes — start, end, PushConst(inclusive)).

AddTyped = 179

Width-typed add: Operand::Width selects I8..F64

SubTyped = 180

Width-typed subtract: Operand::Width selects I8..F64

MulTyped = 181

Width-typed multiply: Operand::Width selects I8..F64

DivTyped = 182

Width-typed divide: Operand::Width selects I8..F64

ModTyped = 183

Width-typed modulo: Operand::Width selects I8..F64

CmpTyped = 184

Width-typed comparison (ordered): Operand::Width selects I8..F64 Result semantics: pushes -1 (a<b), 0 (a==b), or 1 (a>b)

GetDataField = 192

Get field from data row by column index (generic, industry-agnostic)

GetDataRow = 193

Get row reference (lightweight, no data copy)

GetFieldTyped = 208

Get field from typed object using precomputed offset

SetFieldTyped = 209

Set field on typed object using precomputed offset

NewTypedObject = 210

Create a new typed object with fields from stack

TypedMergeObject = 211

Merge two typed objects into a new typed object

WrapTypeAnnotation = 212

Wrap a value with a type annotation for meta formatting

Yield = 224

Yield to event loop for cooperative scheduling

Suspend = 225

Suspend until a condition is met

Resume = 226

Resume from suspension (internal use)

Poll = 227

Poll event queue

AwaitBar = 228

Await next data bar from a source

AwaitTick = 229

Await next timer tick

Await = 230

General-purpose await: suspends on Future values

SpawnTask = 231

Spawn an async task from the expression on top of stack

EmitAlert = 232

Emit an alert to the alert pipeline

EmitEvent = 233

Emit a generic event to the event queue

JoinInit = 234

Initialize a join group from spawned tasks on the stack

JoinAwait = 235

Await a TaskGroup to completion according to its join strategy

CancelTask = 236

Cancel a running task

AsyncScopeEnter = 237

Enter an async scope (structured concurrency boundary)

AsyncScopeExit = 238

Exit an async scope (structured concurrency boundary)

LoadColF64 = 194

Load f64 from typed column on a RowView

LoadColI64 = 195

Load i64 from typed column on a RowView

LoadColBool = 196

Load bool from typed column on a RowView

LoadColStr = 197

Load string from typed column on a RowView

BindSchema = 198

Bind a DataTable to a TypeSchema at runtime (safety net for dynamic paths)

BoxTraitObject = 239

Box a concrete value into a trait object with a vtable

DynMethodCall = 199

Call a method on a trait object via vtable dispatch

DropCall = 200

Call Drop::drop on the value at the top of stack (sync)

DropCallAsync = 201

Call Drop::drop on the value at the top of stack (async)

LoadLocalTrusted = 215

LoadLocal (trusted) – skips tag validation, reads slot directly

JumpIfFalseTrusted = 216

JumpIfFalse (trusted) – condition is known bool, direct bool check

Nop = 240

No operation

Halt = 241

Halt execution

IsNull = 242

Stage 2.6.5: typed absence check. Pops one value, pushes a bool indicating whether the value is the None or Unit sentinel. Replaces the legacy PushNull; Eq and emit_unit; Eq patterns at the 16 null/unit-check sites in the compiler.

IntToNumber = 243

Coerce int to number (i64 -> f64)

NumberToInt = 244

Coerce number to int (f64 -> i64, truncating)

CallForeign = 245

Call a linked foreign function. Dispatches through language runtime extensions or the VM native C ABI path. Operand: ForeignFunction(u16) — index into program.foreign_functions Stack: pops N args (count pushed as a constant by the stub), pushes 1 result

StoreLocalTyped = 246

Store a local with width truncation. Operand: TypedLocal(u16, NumericWidth) — local index + width Pops one value, truncates to declared width, stores to local.

CastWidth = 247

Cast a value to a specific integer width (bit-truncation, Rust-style as). Operand: Width(NumericWidth) — target width Pops one value, truncates, pushes result.

StoreModuleBindingTyped = 248

Store a module binding with width truncation. Operand: TypedModuleBinding(u16, NumericWidth) — binding index + width Pops one value, truncates to declared width, stores to module binding.

NewTypedArrayF64 = 5

Create a new TypedArray with given capacity. Operand: Count(capacity). Pushes ptr.

NewTypedArrayI64 = 6

Create a new TypedArray with given capacity. Operand: Count(capacity). Pushes ptr.

NewTypedArrayI32 = 7

Create a new TypedArray with given capacity. Operand: Count(capacity). Pushes ptr.

TypedArrayGetF64 = 8

Get element from TypedArray: pops (arr_ptr, index), pushes f64 value

TypedArrayGetI64 = 9

Get element from TypedArray: pops (arr_ptr, index), pushes i64 value

TypedArrayGetI32 = 10

Get element from TypedArray: pops (arr_ptr, index), pushes i32 value

TypedArraySetF64 = 11

Set element in TypedArray: pops (arr_ptr, index, value), pushes nothing

TypedArrayPushF64 = 12

Push element to TypedArray: pops (arr_ptr, value), pushes nothing

TypedArrayPushI64 = 13

Push element to TypedArray: pops (arr_ptr, value), pushes nothing

TypedArrayLen = 14

Get length of TypedArray: pops (arr_ptr), pushes len as int

NewTypedArrayBool = 15

Create a new TypedArray with given capacity. Operand: Count(capacity). Pushes ptr.

TypedArrayGetBool = 71

Get element from TypedArray: pops (arr_ptr, index), pushes bool value

TypedArrayPushI32 = 72

Push element to TypedArray: pops (arr_ptr, value), pushes nothing

TypedArrayPushBool = 73

Push element to TypedArray: pops (arr_ptr, value), pushes nothing

TypedArraySetI64 = 74

Set element in TypedArray: pops (arr_ptr, index, value), pushes nothing

TypedArraySetI32 = 75

Set element in TypedArray: pops (arr_ptr, index, value), pushes nothing

TypedArraySetBool = 76

Set element in TypedArray: pops (arr_ptr, index, value), pushes nothing

NewTypedArrayI8 = 16

Create a new TypedArray with given capacity. Operand: Count(capacity). Pushes ptr.

TypedArrayGetI8 = 17

Get element from TypedArray: pops (arr_ptr, index), pushes i8 value (sign-extended to i64).

TypedArrayPushI8 = 18

Push element to TypedArray: pops (arr_ptr, value), pushes nothing.

TypedArraySetI8 = 19

Set element in TypedArray: pops (arr_ptr, index, value), pushes nothing.

NewTypedArrayU8 = 20

Create a new TypedArray with given capacity. Operand: Count(capacity). Pushes ptr.

TypedArrayGetU8 = 21

Get element from TypedArray: pops (arr_ptr, index), pushes u8 value (zero-extended to i64).

TypedArrayPushU8 = 22

Push element to TypedArray: pops (arr_ptr, value), pushes nothing.

TypedArraySetU8 = 32

Set element in TypedArray: pops (arr_ptr, index, value), pushes nothing.

NewTypedArrayI16 = 33

Create a new TypedArray with given capacity. Operand: Count(capacity). Pushes ptr.

TypedArrayGetI16 = 34

Get element from TypedArray: pops (arr_ptr, index), pushes i16 value (sign-extended to i64).

TypedArrayPushI16 = 35

Push element to TypedArray: pops (arr_ptr, value), pushes nothing.

TypedArraySetI16 = 36

Set element in TypedArray: pops (arr_ptr, index, value), pushes nothing.

NewTypedArrayU16 = 37

Create a new TypedArray with given capacity. Operand: Count(capacity). Pushes ptr.

TypedArrayGetU16 = 280

Get element from TypedArray: pops (arr_ptr, index), pushes u16 value (zero-extended to i64).

TypedArrayPushU16 = 281

Push element to TypedArray: pops (arr_ptr, value), pushes nothing.

TypedArraySetU16 = 282

Set element in TypedArray: pops (arr_ptr, index, value), pushes nothing.

NewTypedArrayU32 = 283

Create a new TypedArray with given capacity. Operand: Count(capacity). Pushes ptr.

TypedArrayGetU32 = 284

Get element from TypedArray: pops (arr_ptr, index), pushes u32 value (zero-extended to i64).

TypedArrayPushU32 = 285

Push element to TypedArray: pops (arr_ptr, value), pushes nothing.

TypedArraySetU32 = 286

Set element in TypedArray: pops (arr_ptr, index, value), pushes nothing.

NewTypedArrayF32 = 419

Create a new TypedArray with given capacity. Operand: Count(capacity). Pushes ptr.

TypedArrayGetF32 = 420

Get element from TypedArray: pops (arr_ptr, index), pushes f32 value (zero-extended into f64 bit pattern).

TypedArrayPushF32 = 421

Push element to TypedArray: pops (arr_ptr, value), pushes nothing.

TypedArraySetF32 = 422

Set element in TypedArray: pops (arr_ptr, index, value), pushes nothing.

NewTypedArrayChar = 423

Create a new TypedArray with given capacity. Operand: Count(capacity). Pushes ptr.

TypedArrayGetChar = 424

Get element from TypedArray: pops (arr_ptr, index), pushes char codepoint as u32.

TypedArrayPushChar = 425

Push element to TypedArray: pops (arr_ptr, value), pushes nothing.

TypedArraySetChar = 426

Set element in TypedArray: pops (arr_ptr, index, value), pushes nothing.

NewTypedArrayString = 427

Create a new TypedArray<*const StringObj> with given capacity. Operand: Count(capacity). Pushes ptr.

TypedArrayGetString = 428

Get element from TypedArray<*const StringObj>: pops (arr_ptr, index), pushes (*const StringObj) bits with NativeKind::StringV2 (retains element).

TypedArrayPushString = 429

Push element to TypedArray<*const StringObj>: pops (arr_ptr, value), pushes nothing. Caller transfers their refcount share to the array.

TypedArraySetString = 430

Set element in TypedArray<*const StringObj>: pops (arr_ptr, index, value), pushes nothing. Releases prior element, transfers new value’s refcount share.

NewTypedArrayDecimal = 431

Create a new TypedArray<*const DecimalObj> with given capacity. Operand: Count(capacity). Pushes ptr.

TypedArrayGetDecimal = 432

Get element from TypedArray<*const DecimalObj>: pops (arr_ptr, index), pushes (*const DecimalObj) bits with NativeKind::DecimalV2 (retains element).

TypedArrayPushDecimal = 433

Push element to TypedArray<*const DecimalObj>: pops (arr_ptr, value), pushes nothing. Caller transfers their refcount share to the array.

TypedArraySetDecimal = 434

Set element in TypedArray<*const DecimalObj>: pops (arr_ptr, index, value), pushes nothing. Releases prior element, transfers new value’s refcount share.

NewStringV2 = 435

Create a v2-raw StringObj from a constant string. Operand: Property(string_id). Pushes (*const StringObj) bits with NativeKind::StringV2 (refcount = 1, owned by caller).

NewDecimalV2 = 436

Create a v2-raw DecimalObj from a constant decimal. Operand: Const(constant_id). Pushes (*const DecimalObj) bits with NativeKind::DecimalV2 (refcount = 1, owned by caller).

NewTypedArrayTypedObject = 437

Create a new TypedArray<*const TypedObjectStorage> with given capacity. Operand: Count(capacity). Pushes ptr.

TypedArrayGetTypedObject = 438

Get element from TypedArray<*const TypedObjectStorage>: pops (arr_ptr, index), pushes (*const TypedObjectStorage) bits with NativeKind::Ptr(HeapKind::TypedObject) (retains element).

TypedArrayPushTypedObject = 439

Push element to TypedArray<*const TypedObjectStorage>: pops (arr_ptr, value), pushes nothing. Caller transfers their refcount share to the array.

TypedArraySetTypedObject = 440

Set element in TypedArray<*const TypedObjectStorage>: pops (arr_ptr, index, value), pushes nothing. Releases prior element, transfers new value’s refcount share.

NewTypedMapStringF64 = 205

Allocate a new TypedMap<*const StringObj, f64>. Pushes ptr.

NewTypedMapStringI64 = 206

Allocate a new TypedMap<*const StringObj, i64>. Pushes ptr.

NewTypedMapStringPtr = 207

Allocate a new TypedMap<*const StringObj, *const u8>. Pushes ptr.

NewTypedMapI64F64 = 213

Allocate a new TypedMap<i64, f64>. Pushes ptr.

NewTypedMapI64I64 = 214

Allocate a new TypedMap<i64, i64>. Pushes ptr.

NewTypedMapI64Ptr = 217

Allocate a new TypedMap<i64, *const u8>. Pushes ptr.

TypedMapStringF64Get = 218

String→f64 get: pops (map_ptr, key), pushes f64 (or null).

TypedMapStringI64Get = 219

String→i64 get: pops (map_ptr, key), pushes i64 (or null).

TypedMapStringPtrGet = 220

String→Ptr get: pops (map_ptr, key), pushes ptr (or null).

TypedMapI64F64Get = 221

I64→f64 get: pops (map_ptr, key), pushes f64 (or null).

TypedMapI64I64Get = 222

I64→i64 get: pops (map_ptr, key), pushes i64 (or null).

TypedMapI64PtrGet = 223

I64→Ptr get: pops (map_ptr, key), pushes ptr (or null).

TypedMapStringF64Set = 77

String→f64 set: pops (map_ptr, key, value).

TypedMapStringI64Set = 78

String→i64 set: pops (map_ptr, key, value).

TypedMapStringPtrSet = 79

String→Ptr set: pops (map_ptr, key, value).

TypedMapI64F64Set = 109

I64→f64 set: pops (map_ptr, key, value).

TypedMapI64I64Set = 110

I64→i64 set: pops (map_ptr, key, value).

TypedMapI64PtrSet = 111

I64→Ptr set: pops (map_ptr, key, value).

TypedMapStringF64Has = 142

String→f64 has: pops (map_ptr, key), pushes bool.

TypedMapStringI64Has = 143

String→i64 has: pops (map_ptr, key), pushes bool.

TypedMapStringPtrHas = 185

String→Ptr has: pops (map_ptr, key), pushes bool.

TypedMapI64F64Has = 186

I64→f64 has: pops (map_ptr, key), pushes bool.

TypedMapI64I64Has = 187

I64→i64 has: pops (map_ptr, key), pushes bool.

TypedMapI64PtrHas = 188

I64→Ptr has: pops (map_ptr, key), pushes bool.

TypedMapStringF64Delete = 189

String→f64 delete: pops (map_ptr, key).

TypedMapStringI64Delete = 190

String→i64 delete: pops (map_ptr, key).

TypedMapStringPtrDelete = 191

String→Ptr delete: pops (map_ptr, key).

TypedMapI64F64Delete = 249

I64→f64 delete: pops (map_ptr, key).

TypedMapI64I64Delete = 250

I64→i64 delete: pops (map_ptr, key).

TypedMapI64PtrDelete = 251

I64→Ptr delete: pops (map_ptr, key).

StringConcat = 252

Concatenate two heap strings/chars, pushing a new string. Pops (a, b).

ArrayConcat = 253

Concatenate two arrays, pushing a new array. Pops (a, b).

EqString = 254

Equal (string × string → bool). Pops two *const StringObj, content-compares the UTF-8 bytes, pushes bool. Both operands must be non-null v2 StringObj pointers. Use Neq via EqString; Not.

EqDecimal = 255

Equal (decimal × decimal → bool). Pops two *const DecimalObj, content-compares the decimal payloads, pushes bool. Both operands must be non-null v2 DecimalObj pointers. Use Neq via EqDecimal; Not.

GtString = 256

Greater than (string × string → bool). Lexicographic comparison.

LtString = 257

Less than (string × string → bool). Lexicographic comparison.

GteString = 258

Greater than or equal (string × string → bool). Lexicographic comparison.

LteString = 259

Less than or equal (string × string → bool). Lexicographic comparison.

LoadLocalMove = 260

Load local with Move semantics — transfers ownership, source slot is zeroed. Used when the compiler proves the source binding is dead after this point.

LoadLocalClone = 261

Load local with Clone semantics — clones the value, source stays live. For heap-tagged values, this bumps the Arc refcount.

StoreLocalDrop = 262

Store local with Drop semantics — drops the old value before storing. Respects ownership: if old value is uniquely owned, frees immediately.

PromoteToOwned = 263

Promote top-of-stack from shared (Arc) to owned (Box) allocation if the refcount is 1. No-op for inline values or already-owned values. Used by the compiler before StoreLocal for uniquely-owned let bindings.

GetElemI64 = 264

Get i64 element from typed int array. Operand: local slot. Index on stack.

GetElemF64 = 265

Get f64 element from typed float array. Operand: local slot. Index on stack.

SetElemI64 = 266

Set i64 element in typed int array. Operand: local slot. Index and value on stack.

SetElemF64 = 267

Set f64 element in typed float array. Operand: local slot. Index and value on stack.

ArrayPushI64 = 268

Push i64 to typed int array. Operand: local slot. Value on stack.

ArrayPushF64 = 269

Push f64 to typed float array. Operand: local slot. Value on stack.

ArrayLenTyped = 270

Get length of typed array (any element type). Operand: local slot.

MapGetStrI64 = 271

Get value from HashMap<string, int>. Key on stack. Operand: map slot.

MapGetStrF64 = 272

Get value from HashMap<string, float>. Key on stack. Operand: map slot.

MapSetStrI64 = 273

Set value in HashMap<string, int>. Key and value on stack. Operand: map slot.

MapHasStr = 274

Check if key exists in HashMap<string, *>. Key on stack. Operand: map slot.

MapLenTyped = 275

Get HashMap length. Operand: map slot.

StringLenTyped = 276

Get string length (chars). Operand: string slot.

StringCharAt = 277

Get char at index. Index on stack. Operand: string slot.

StringConcatTyped = 278

Concatenate two strings. Both on stack.

ReturnOwned = 279

Phase 5.C: Return with owned semantics. Pops the top-of-stack return value, promotes Arc→Box when refcount is exactly 1 (as PromoteToOwned does), then falls through to the normal return path. Emitted by the compiler in place of the implicit return-slot store for functions whose inferred ReturnOwnershipMode is NewlyOwned, so the callee already hands a uniquely-owned value to the caller and the caller can skip its own PromoteToOwned.

Stack effect is identical to PromoteToOwned — it operates on the value already on the stack and leaves it in place; the control flow is handled by the subsequent Return instruction or by the function epilogue, not by this opcode itself.

LoadOwnedMutableCapture = 306

Load through an OwnedMutable capture’s *mut <T> cell. Operand: Local(idx). Pushes the dereferenced cell payload as raw 8 bytes paired with the cell’s inner_kind (sourced from ClosureLayout::capture_inner_kinds).

StoreOwnedMutableCapture = 307

Store through an OwnedMutable capture’s *mut <T> cell. Operand: Local(idx). Pops the value to write (raw 8 bytes + payload kind from the kinded stack ABI; ADR-006 §2.7.7).

LoadSharedCapture = 308

Load through a Shared capture’s *const SharedCell cell — takes the parking_lot mutex for the read only. Operand: Local(idx). Pushes the inner payload as raw 8 bytes + cell’s inner-payload kind.

StoreSharedCapture = 309

Store through a Shared capture’s *const SharedCell cell — takes the parking_lot mutex for the write only. Operand: Local(idx). Pops the value to write (raw bits + inner-payload kind).

LoadOwnedMutableCaptureI64 = 320

Load i64 through an OwnedMutable capture’s *mut i64 cell. Operand: Local(idx). Pushes the dereferenced i64 onto the stack as a raw i64.

LoadOwnedMutableCaptureU64 = 321

Load u64 through an OwnedMutable capture’s *mut u64 cell. Operand: Local(idx). Pushes the dereferenced u64 bits onto the stack as raw u64.

LoadOwnedMutableCaptureF64 = 322

Load f64 through an OwnedMutable capture’s *mut f64 cell. Operand: Local(idx). Pushes the dereferenced f64 onto the stack as a raw f64.

LoadOwnedMutableCaptureI32 = 323

Load i32 through an OwnedMutable capture’s *mut i32 cell. Operand: Local(idx). Sign-extends the i32 to i64 and pushes it as a raw i64 (sub-i64 ints share the i64 stack convention).

LoadOwnedMutableCaptureU32 = 324

Load u32 through an OwnedMutable capture’s *mut u32 cell. Operand: Local(idx). Zero-extends the u32 to i64 and pushes it as a raw i64.

LoadOwnedMutableCaptureI16 = 325

Load i16 through an OwnedMutable capture’s *mut i16 cell. Operand: Local(idx). Sign-extends the i16 to i64 and pushes it as a raw i64.

LoadOwnedMutableCaptureU16 = 326

Load u16 through an OwnedMutable capture’s *mut u16 cell. Operand: Local(idx). Zero-extends the u16 to i64 and pushes it as a raw i64.

LoadOwnedMutableCaptureI8 = 327

Load i8 through an OwnedMutable capture’s *mut i8 cell. Operand: Local(idx). Sign-extends the i8 to i64 and pushes it as a raw i64.

LoadOwnedMutableCaptureU8 = 328

Load u8 through an OwnedMutable capture’s *mut u8 cell. Operand: Local(idx). Zero-extends the u8 to i64 and pushes it as a raw i64.

LoadOwnedMutableCaptureBool = 329

Load bool through an OwnedMutable capture’s *mut bool cell. Operand: Local(idx). Pushes the dereferenced bool onto the stack via the typed bool-push helper.

LoadOwnedMutableCapturePtr = 330

Load Ptr through an OwnedMutable capture’s *mut u64 cell. Operand: Local(idx). Pushes the dereferenced 8-byte pointer-shaped payload as raw u64 (raw heap-Arc pointer bits paired with the cell’s NativeKind::Ptr(HeapKind::*) per ADR-006 §2.7.8). Refcount retain semantics for Ptr payloads are the caller’s responsibility — matches the read_owned_mutable_ptr contract: this opcode does NOT clone.

StoreOwnedMutableCaptureI64 = 331

Store i64 through an OwnedMutable capture’s *mut i64 cell. Operand: Local(idx). Pops a raw i64 and writes it into the cell.

StoreOwnedMutableCaptureU64 = 332

Store u64 through an OwnedMutable capture’s *mut u64 cell. Operand: Local(idx). Pops a raw u64 and writes it into the cell.

StoreOwnedMutableCaptureF64 = 333

Store f64 through an OwnedMutable capture’s *mut f64 cell. Operand: Local(idx). Pops a raw f64 and writes it into the cell.

StoreOwnedMutableCaptureI32 = 334

Store i32 through an OwnedMutable capture’s *mut i32 cell. Operand: Local(idx). Pops a raw i64 from the stack, truncates to the low 32 bits, and writes the i32 payload.

StoreOwnedMutableCaptureU32 = 335

Store u32 through an OwnedMutable capture’s *mut u32 cell. Operand: Local(idx). Pops a raw i64, truncates to the low 32 bits, and writes the u32 payload.

StoreOwnedMutableCaptureI16 = 336

Store i16 through an OwnedMutable capture’s *mut i16 cell. Operand: Local(idx). Pops a raw i64, truncates to the low 16 bits, and writes the i16 payload.

StoreOwnedMutableCaptureU16 = 337

Store u16 through an OwnedMutable capture’s *mut u16 cell. Operand: Local(idx). Pops a raw i64, truncates to the low 16 bits, and writes the u16 payload.

StoreOwnedMutableCaptureI8 = 338

Store i8 through an OwnedMutable capture’s *mut i8 cell. Operand: Local(idx). Pops a raw i64, truncates to the low 8 bits, and writes the i8 payload.

StoreOwnedMutableCaptureU8 = 339

Store u8 through an OwnedMutable capture’s *mut u8 cell. Operand: Local(idx). Pops a raw i64, truncates to the low 8 bits, and writes the u8 payload.

StoreOwnedMutableCaptureBool = 340

Store bool through an OwnedMutable capture’s *mut bool cell. Operand: Local(idx). Pops a bool via the typed bool-pop helper and writes it into the cell.

StoreOwnedMutableCapturePtr = 341

Store Ptr through an OwnedMutable capture’s *mut u64 cell. Operand: Local(idx). Pops a raw u64 (heap-Arc pointer bits + NativeKind::Ptr(HeapKind::*) per ADR-006 §2.7.7) and writes it into the cell. Refcount semantics are the caller’s responsibility — matches the write_owned_mutable_ptr contract: this opcode does NOT release the previous payload nor retain the new one.

LoadSharedCaptureI64 = 342

Load an i64 through a Shared capture cell — locks the mutex, reads the i64 payload, unlocks, pushes the raw i64 onto the stack. Operand: Local(idx).

LoadSharedCaptureU64 = 343

Load a u64 through a Shared capture cell — locks, reads the u64 payload, unlocks, pushes the raw u64 bits. Operand: Local(idx).

LoadSharedCaptureF64 = 344

Load an f64 through a Shared capture cell — locks, reads the f64 payload, unlocks, pushes the raw f64. Operand: Local(idx).

LoadSharedCaptureI32 = 345

Load an i32 through a Shared capture cell — locks, reads the low 4 bytes of the payload as i32, unlocks, sign-extends, pushes. Operand: Local(idx).

LoadSharedCaptureU32 = 346

Load a u32 through a Shared capture cell — locks, reads the low 4 bytes of the payload as u32, unlocks, zero-extends, pushes. Operand: Local(idx).

LoadSharedCaptureI16 = 347

Load an i16 through a Shared capture cell — locks, reads the low 2 bytes of the payload as i16, unlocks, sign-extends, pushes. Operand: Local(idx).

LoadSharedCaptureU16 = 348

Load a u16 through a Shared capture cell — locks, reads the low 2 bytes of the payload as u16, unlocks, zero-extends, pushes. Operand: Local(idx).

LoadSharedCaptureI8 = 349

Load an i8 through a Shared capture cell — locks, reads the low byte of the payload as i8, unlocks, sign-extends, pushes. Operand: Local(idx).

LoadSharedCaptureU8 = 350

Load a u8 through a Shared capture cell — locks, reads the low byte of the payload as u8, unlocks, zero-extends, pushes. Operand: Local(idx).

LoadSharedCaptureBool = 351

Load a bool through a Shared capture cell — locks, reads the low byte of the payload (zero ⇒ false; non-zero ⇒ true), unlocks, pushes a raw NaN-tagged bool onto the stack. Operand: Local(idx).

LoadSharedCapturePtr = 352

Load a Ptr through a Shared capture cell — locks, reads the 8 payload bytes as a raw u64 (heap-Arc pointer bits paired with the cell’s NativeKind::Ptr(HeapKind::*) per ADR-006 §2.7.8 / Q10), unlocks, pushes the raw bits. Refcount retain semantics for Ptr payloads are the caller’s responsibility (the helper does NOT clone — match the read_shared_ptr contract). Operand: Local(idx).

StoreSharedCaptureI64 = 353

Store an i64 through a Shared capture cell — pops a raw i64 from the stack, locks, writes the 8-byte i64 payload, unlocks. Operand: Local(idx).

StoreSharedCaptureU64 = 354

Store a u64 through a Shared capture cell — pops a raw u64, locks, writes the 8-byte u64 payload, unlocks. Operand: Local(idx).

StoreSharedCaptureF64 = 355

Store an f64 through a Shared capture cell — pops a raw f64, locks, writes the 8-byte f64 payload, unlocks. Operand: Local(idx).

StoreSharedCaptureI32 = 356

Store an i32 through a Shared capture cell — pops a raw i32, sign-extends to 8 bytes, locks, writes payload, unlocks. Operand: Local(idx).

StoreSharedCaptureU32 = 357

Store a u32 through a Shared capture cell — pops a raw u32, zero-extends to 8 bytes, locks, writes payload, unlocks. Operand: Local(idx).

StoreSharedCaptureI16 = 358

Store an i16 through a Shared capture cell — pops a raw i16, sign-extends to 8 bytes, locks, writes payload, unlocks. Operand: Local(idx).

StoreSharedCaptureU16 = 359

Store a u16 through a Shared capture cell — pops a raw u16, zero-extends to 8 bytes, locks, writes payload, unlocks. Operand: Local(idx).

StoreSharedCaptureI8 = 360

Store an i8 through a Shared capture cell — pops a raw i8, sign-extends to 8 bytes, locks, writes payload, unlocks. Operand: Local(idx).

StoreSharedCaptureU8 = 361

Store a u8 through a Shared capture cell — pops a raw u8, zero-extends to 8 bytes, locks, writes payload, unlocks. Operand: Local(idx).

StoreSharedCaptureBool = 362

Store a bool through a Shared capture cell — pops a raw bool, locks, writes the 8-byte payload as 0 or 1, unlocks. Operand: Local(idx).

StoreSharedCapturePtr = 363

Store a Ptr through a Shared capture cell — pops raw 8-byte bits (heap-Arc pointer bits + NativeKind::Ptr(HeapKind::*) per ADR-006 §2.7.7), locks, writes the payload, unlocks. The caller is responsible for refcount semantics on Ptr payloads — matches the write_shared_ptr contract: this opcode does NOT release the previous payload nor retain the new one. Operand: Local(idx).

LoadLocalI64 = 364

Load i64 from local slot — reads raw 8 bytes, pushes as i64. Operand: Local(idx).

LoadLocalU64 = 365

Load u64 from local slot — reads raw 8 bytes, pushes as u64. Operand: Local(idx).

LoadLocalF64 = 366

Load f64 from local slot — reads raw 8 bytes, pushes as f64. Operand: Local(idx).

LoadLocalI32 = 367

Load i32 from local slot — reads low 4 bytes, sign-extends to i64 in the 8-byte stack slot. Operand: Local(idx).

LoadLocalU32 = 368

Load u32 from local slot — reads low 4 bytes, zero-extends to u64 in the 8-byte stack slot. Operand: Local(idx).

LoadLocalI16 = 369

Load i16 from local slot — reads low 2 bytes, sign-extends to i64 in the 8-byte stack slot. Operand: Local(idx).

LoadLocalU16 = 370

Load u16 from local slot — reads low 2 bytes, zero-extends to u64 in the 8-byte stack slot. Operand: Local(idx).

LoadLocalI8 = 371

Load i8 from local slot — reads low byte, sign-extends to i64 in the 8-byte stack slot. Operand: Local(idx).

LoadLocalU8 = 372

Load u8 from local slot — reads low byte, zero-extends to u64 in the 8-byte stack slot. Operand: Local(idx).

LoadLocalBool = 373

Load bool from local slot — reads low byte (zero ⇒ false; non-zero ⇒ true) and pushes the raw 8 bytes back. Operand: Local(idx).

LoadLocalPtr = 374

Load Ptr from local slot — reads raw 8 bytes (heap-Arc pointer bits paired with the slot’s NativeKind::Ptr(HeapKind::*) per ADR-006 §2.7.7) and pushes them. The handler does NOT clone / retain — refcount semantics are the caller’s responsibility. Operand: Local(idx).

StoreLocalI64 = 375

Store i64 to local slot — pops raw i64, writes 8 bytes to slot. Operand: Local(idx).

StoreLocalU64 = 376

Store u64 to local slot — pops raw u64, writes 8 bytes to slot. Operand: Local(idx).

StoreLocalF64 = 377

Store f64 to local slot — pops raw f64, writes 8 bytes to slot. Operand: Local(idx).

StoreLocalI32 = 378

Store i32 to local slot — pops 8-byte slot, truncates to i32 (low 4 bytes, sign-extended back into 8-byte slot for storage). Operand: Local(idx).

StoreLocalU32 = 379

Store u32 to local slot — pops 8-byte slot, truncates to u32 (low 4 bytes, zero-extended back into 8-byte slot for storage). Operand: Local(idx).

StoreLocalI16 = 380

Store i16 to local slot — pops 8-byte slot, truncates to i16 (low 2 bytes, sign-extended back into 8-byte slot for storage). Operand: Local(idx).

StoreLocalU16 = 381

Store u16 to local slot — pops 8-byte slot, truncates to u16 (low 2 bytes, zero-extended back into 8-byte slot for storage). Operand: Local(idx).

StoreLocalI8 = 382

Store i8 to local slot — pops 8-byte slot, truncates to i8 (low byte, sign-extended back into 8-byte slot for storage). Operand: Local(idx).

StoreLocalU8 = 383

Store u8 to local slot — pops 8-byte slot, truncates to u8 (low byte, zero-extended back into 8-byte slot for storage). Operand: Local(idx).

StoreLocalBool = 384

Store bool to local slot — pops raw 8-byte slot, writes a canonical 0 or 1 in the slot’s low byte (any nonzero pop ⇒ 1). Operand: Local(idx).

StoreLocalPtr = 385

Store Ptr to local slot — pops raw 8 bytes (heap-Arc pointer bits + NativeKind::Ptr(HeapKind::*) per ADR-006 §2.7.7) and writes them to the slot. The handler does NOT release the previous payload nor retain the new one — refcount semantics are the caller’s responsibility (matches the D.1 / D.2 Ptr contract). Operand: Local(idx).

LoadModuleBindingI64 = 386

Load an i64 from module_bindings[idx] — reads the 8-byte slot as i64 and pushes the raw bits onto the stack. Operand: ModuleBinding(idx).

LoadModuleBindingU64 = 387

Load a u64 from module_bindings[idx] — reads the 8-byte slot as u64 and pushes the raw bits. Operand: ModuleBinding(idx).

LoadModuleBindingF64 = 388

Load an f64 from module_bindings[idx] — reads the 8-byte slot as f64 and pushes the raw bits. Operand: ModuleBinding(idx).

LoadModuleBindingI32 = 389

Load an i32 from module_bindings[idx] — reads the low 4 bytes of the slot as i32, sign-extends to i64, pushes the raw bits. Operand: ModuleBinding(idx).

LoadModuleBindingU32 = 390

Load a u32 from module_bindings[idx] — reads the low 4 bytes of the slot as u32, zero-extends to u64, pushes. Operand: ModuleBinding(idx).

LoadModuleBindingI16 = 391

Load an i16 from module_bindings[idx] — reads the low 2 bytes of the slot as i16, sign-extends to i64, pushes. Operand: ModuleBinding(idx).

LoadModuleBindingU16 = 392

Load a u16 from module_bindings[idx] — reads the low 2 bytes of the slot as u16, zero-extends to u64, pushes. Operand: ModuleBinding(idx).

LoadModuleBindingI8 = 393

Load an i8 from module_bindings[idx] — reads the low byte of the slot as i8, sign-extends to i64, pushes. Operand: ModuleBinding(idx).

LoadModuleBindingU8 = 394

Load a u8 from module_bindings[idx] — reads the low byte of the slot as u8, zero-extends to u64, pushes. Operand: ModuleBinding(idx).

LoadModuleBindingBool = 395

Load a bool from module_bindings[idx] — reads the low byte (zero ⇒ false; non-zero ⇒ true), pushes 0/1 as raw u64. Operand: ModuleBinding(idx).

LoadModuleBindingPtr = 396

Load a Ptr from module_bindings[idx] — reads the 8-byte slot as raw u64 (heap-Arc pointer bits paired with the binding’s NativeKind::Ptr(HeapKind::*) per ADR-006 §2.7.7) and pushes. Refcount retain semantics for Ptr payloads are the caller’s responsibility — this opcode does NOT clone_with_kind. Operand: ModuleBinding(idx).

StoreModuleBindingI64 = 397

Store an i64 to module_bindings[idx] — pops raw i64 bits, writes the full 8-byte slot. Operand: ModuleBinding(idx).

StoreModuleBindingU64 = 398

Store a u64 to module_bindings[idx] — pops raw u64 bits, writes the full 8-byte slot. Operand: ModuleBinding(idx).

StoreModuleBindingF64 = 399

Store an f64 to module_bindings[idx] — pops raw f64 bits, writes the full 8-byte slot. Operand: ModuleBinding(idx).

StoreModuleBindingI32 = 400

Store an i32 to module_bindings[idx] — pops raw u64, truncates to i32, sign-extends to i64, writes the 8-byte slot. Operand: ModuleBinding(idx).

StoreModuleBindingU32 = 401

Store a u32 to module_bindings[idx] — pops raw u64, truncates to u32, zero-extends to u64, writes the 8-byte slot. Operand: ModuleBinding(idx).

StoreModuleBindingI16 = 402

Store an i16 to module_bindings[idx] — pops raw u64, truncates to i16, sign-extends to i64, writes the 8-byte slot. Operand: ModuleBinding(idx).

StoreModuleBindingU16 = 403

Store a u16 to module_bindings[idx] — pops raw u64, truncates to u16, zero-extends to u64, writes the 8-byte slot. Operand: ModuleBinding(idx).

StoreModuleBindingI8 = 404

Store an i8 to module_bindings[idx] — pops raw u64, truncates to i8, sign-extends to i64, writes the 8-byte slot. Operand: ModuleBinding(idx).

StoreModuleBindingU8 = 405

Store a u8 to module_bindings[idx] — pops raw u64, truncates to u8, zero-extends to u64, writes the 8-byte slot. Operand: ModuleBinding(idx).

StoreModuleBindingBool = 406

Store a bool to module_bindings[idx] — pops raw u64 (any non-zero bit pattern ⇒ true), writes the 8-byte slot as 0 or 1. Operand: ModuleBinding(idx).

StoreModuleBindingPtr = 407

Store a Ptr to module_bindings[idx] — pops raw 8-byte bits (heap-Arc pointer bits + NativeKind::Ptr(HeapKind::*) per ADR-006 §2.7.7) and writes the slot. The caller is responsible for refcount semantics — this opcode does NOT release the previous payload nor retain the new one. Operand: ModuleBinding(idx).

ReturnValueI64 = 408

Return with i64 value — pops 1 raw i64, frame-cleans, pushes 1.

ReturnValueU64 = 409

Return with u64 value — pops 1 raw u64, frame-cleans, pushes 1.

ReturnValueF64 = 410

Return with f64 value — pops 1 raw f64, frame-cleans, pushes 1.

ReturnValueI32 = 411

Return with i32 value — pops 1 raw i32 (in i64 slot), frame-cleans, pushes 1.

ReturnValueU32 = 412

Return with u32 value — pops 1 raw u32 (in i64 slot), frame-cleans, pushes 1.

ReturnValueI16 = 413

Return with i16 value — pops 1 raw i16 (in i64 slot), frame-cleans, pushes 1.

ReturnValueU16 = 414

Return with u16 value — pops 1 raw u16 (in i64 slot), frame-cleans, pushes 1.

ReturnValueI8 = 415

Return with i8 value — pops 1 raw i8 (in i64 slot), frame-cleans, pushes 1.

ReturnValueU8 = 416

Return with u8 value — pops 1 raw u8 (in i64 slot), frame-cleans, pushes 1.

ReturnValueBool = 417

Return with bool value — pops 1 raw bool, frame-cleans, pushes 1.

ReturnValuePtr = 418

Return with Ptr value — pops 1 raw 8-byte heap-Arc pointer payload (paired with NativeKind::Ptr(HeapKind::*) per ADR-006 §2.7.7), frame-cleans, pushes 1. Ownership transfer is by raw bit-level pass-through; the handler does NOT retain or release.

AllocSharedLocal = 310

Pop the top-of-stack value (raw bits + payload NativeKind), allocate a fresh Arc<parking_lot::Mutex<SharedCell>>, and store the Arc::into_raw pointer bits into local slot slot. Operand: Local(idx). Sole allocator for Shared locals.

LoadSharedLocal = 311

Read the SharedCell pointer bits from local slot slot, take the parking_lot mutex for a read, clone the inner cell payload (raw bits + the cell’s inner NativeKind per ADR-006 §2.7.8), drop the guard, push onto the stack. Operand: Local(idx).

StoreSharedLocal = 312

Pop a value (raw bits + payload NativeKind), read the SharedCell pointer bits from local slot slot, take the parking_lot mutex for a write, overwrite the inner cell payload, drop the guard. The slot’s pointer bits are NOT modified. Operand: Local(idx).

DropSharedLocal = 313

Read the SharedCell pointer bits from local slot slot, reconstruct Arc::from_raw, drop the Arc (one atomic strong-count decrement), and overwrite the slot with NONE_BITS to mark it spent. Operand: Local(idx). Sole releaser for Shared locals — emitted by the compiler at scope exit.

AllocSharedModuleBinding = 314

Pop the top-of-stack value (raw bits + payload NativeKind), allocate a fresh Arc<parking_lot::Mutex<SharedCell>>, and store the Arc::into_raw pointer bits into module_bindings[idx]. Operand: ModuleBinding(idx). Sole allocator for Shared module bindings.

LoadSharedModuleBinding = 315

Read the SharedCell pointer bits from module_bindings[idx], take the parking_lot mutex for a read, clone the inner cell payload (raw bits + the cell’s inner NativeKind per ADR-006 §2.7.8), drop the guard, push onto the stack. Operand: ModuleBinding(idx).

StoreSharedModuleBinding = 316

Pop a value (raw bits + payload NativeKind), read the SharedCell pointer bits from module_bindings[idx], take the parking_lot mutex for a write, overwrite the inner cell payload, drop the guard. The slot’s pointer bits are NOT modified. Operand: ModuleBinding(idx).

CallClosure = 291

Direct dispatch on a closure value whose ClosureTypeId is statically known at the call site. Operand: Count(arity).

Stack layout before: [closure, arg0, arg1, ..., argN-1]. Stack layout after: [result].

CallFunctionIndirect = 292

Polymorphic dispatch through a Function<A, R> value. Operand: Count(arity). Same stack layout as CallClosure.

MoveLocal = 293

V1.1A (UNWIRED): Move value out of a local slot — transfers ownership without refcount bump, source slot is invalidated. Pushes the value. Executor handler added in V1.1B; currently unreachable via dispatch.

CloneLocal = 294

V1.1A (UNWIRED): Clone value from a local slot with refcount-aware semantics — for heap-tagged shared values bumps Arc refcount; for owned values performs a deep clone. Source stays live. Pushes the value. Executor handler added in V1.1B; currently unreachable via dispatch.

DropLocal = 295

V1.1A (UNWIRED): Explicit drop of a local slot at scope exit — for owned heap values frees immediately; for shared values decrements the refcount. No stack effect. Executor handler added in V1.1B; currently unreachable via dispatch.

PromoteToShared = 296

V1.2A (UNWIRED): Demote/promote the top-of-stack value from Box-owned to Arc-shared allocation. No-op for inline values or already-shared heap values. Executor handler added in V1.2B; currently unreachable via dispatch — reaching this opcode panics.

FieldLoadF64 = 130

Load f64 field from typed struct at byte offset. Operand: FieldOffset(u16). Pops struct_ptr, pushes f64.

FieldLoadI64 = 131

Load i64 field from typed struct at byte offset. Operand: FieldOffset(u16). Pops struct_ptr, pushes i64.

FieldLoadI32 = 132

Load i32 field from typed struct at byte offset. Operand: FieldOffset(u16). Pops struct_ptr, pushes i32.

FieldLoadBool = 133

Load bool field from typed struct at byte offset. Operand: FieldOffset(u16). Pops struct_ptr, pushes bool.

FieldLoadPtr = 134

Load ptr field from typed struct at byte offset. Operand: FieldOffset(u16). Pops struct_ptr, pushes ptr.

FieldStoreF64 = 135

Store f64 field to typed struct at byte offset. Operand: FieldOffset(u16). Pops (struct_ptr, value).

FieldStoreI64 = 139

Store i64 field to typed struct at byte offset. Operand: FieldOffset(u16). Pops (struct_ptr, value).

FieldStoreI32 = 140

Store i32 field to typed struct at byte offset. Operand: FieldOffset(u16). Pops (struct_ptr, value).

NewTypedStruct = 141

Allocate a new typed struct. Operand: TypedObjectAlloc{schema_id, field_count}. Pushes ptr.

AddI32 = 29

Add (i32 x i32 -> i32)

SubI32 = 30

Subtract (i32 x i32 -> i32)

MulI32 = 31

Multiply (i32 x i32 -> i32)

DivI32 = 158

Divide (i32 x i32 -> i32)

ModI32 = 159

Modulo (i32 x i32 -> i32)

EqI32 = 170

Equal (i32 x i32 -> bool)

NeqI32 = 171

Not equal (i32 x i32 -> bool)

LtI32 = 172

Less than (i32 x i32 -> bool)

GtI32 = 173

Greater than (i32 x i32 -> bool)

LteI32 = 174

Less than or equal (i32 x i32 -> bool)

GteI32 = 175

Greater than or equal (i32 x i32 -> bool)

BitAndInt = 297

R5.1A (UNWIRED): Bitwise AND on two i64 values (int × int → int). Executor handler added in R5.1B; currently unreachable via dispatch.

BitOrInt = 298

R5.1A (UNWIRED): Bitwise OR on two i64 values (int × int → int). Executor handler added in R5.1B; currently unreachable via dispatch.

BitXorInt = 299

R5.1A (UNWIRED): Bitwise XOR on two i64 values (int × int → int). Executor handler added in R5.1B; currently unreachable via dispatch.

BitShlInt = 300

R5.1A (UNWIRED): Bitwise shift-left on two i64 values (int × int → int). Executor handler added in R5.1B; currently unreachable via dispatch.

BitShrInt = 301

R5.1A (UNWIRED): Bitwise arithmetic shift-right on two i64 values (int × int → int). Matches Shape’s >> operator semantics. Executor handler added in R5.1B; currently unreachable via dispatch.

BitNotInt = 302

R5.1A (UNWIRED): Bitwise NOT on an i64 value (int → int). Executor handler added in R5.1B; currently unreachable via dispatch.

StringConcatInt = 303

R5.5: Concatenate a heap string with an int scalar. Pops (string, i64 raw int), formats the int via format!("{}{}", s, i), pushes a newly-allocated string. Compile-time proof of operand types — no tag checks beyond the string decode.

StringConcatNumber = 304

R5.5: Concatenate a heap string with a number scalar. Pops (string, raw f64), formats the number via the same integer-fast-path logic as the legacy fallback (whole numbers render without a decimal), pushes a newly-allocated string. Compile-time proof of operand types.

StringConcatBool = 305

R5.5: Concatenate a heap string with a bool scalar. Pops (string, raw bool), formats the bool as "true" / "false", pushes a newly-allocated string. Compile-time proof of operand types.

Implementations

impl OpCode

pub const fn category(self) -> OpcodeCategory

Returns the category this opcode belongs to.

pub const fn stack_pops(self) -> u8

Returns the number of values this opcode pops from the stack. Returns 0 for variable-arity opcodes (Call, CallMethod, NewArray, etc.).

pub const fn stack_pushes(self) -> u8

Returns the number of values this opcode pushes onto the stack. Returns 0 for variable-arity opcodes.

impl OpCode

pub const fn is_trusted(self) -> bool

Returns true if this is a trusted opcode variant (compiler-proved types, no runtime guard).

pub const fn guarded_variant(self) -> Option<OpCode>

Map a trusted opcode back to its guarded (runtime-checked) counterpart.

This is the inverse of trusted_variant(): given a trusted opcode, it returns the equivalent guarded opcode. Used for differential testing and bytecode post-processing.

pub const fn is_v2_typed(self) -> bool

Returns true if this is a v2 typed opcode (typed arrays, typed fields, sized integers). These opcodes carry their type in the opcode name and require the v2 runtime path.

pub const fn trusted_variant(self) -> Option<OpCode>

Map a guarded typed opcode to its trusted variant (if one exists).

Trait Implementations

impl Clone for OpCode

fn clone(&self) -> OpCode

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for OpCode

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for OpCode

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for OpCode

fn eq(&self, other: &OpCode) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for OpCode

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for OpCode

impl Eq for OpCode

impl StructuralPartialEq for OpCode