Refactored all OP_ functions to vm/CATEGORY/ and renamed the files.

src/vm/arrays/arr_insert.c

@@ -0,0 +1,18 @@
+case OP_ARR_INSERT: {
+    Value v = pop_value(vm);
+    Value idx = pop_value(vm);
+    Value arr = pop_value(vm);
+    if (arr.type != VAL_ARRAY || idx.type != VAL_INT) {
+        fprintf(stderr, "Runtime type error: ARR_INSERT expects (array, int, value)\n");
+        exit(1);
+    }
+    int n = array_insert(&arr, (int)idx.i, v);
+    if (n < 0) {
+        fprintf(stderr, "Runtime error: insert failed (OOM?)\n");
+        exit(1);
+    }
+    free_value(arr);
+    free_value(idx);
+    push_value(vm, make_int(n));
+    break;
+}

src/vm/arrays/arr_pop.c

@@ -0,0 +1,15 @@
+case OP_ARR_POP: {
+    Value arr = pop_value(vm);
+    if (arr.type != VAL_ARRAY) {
+        fprintf(stderr, "Runtime type error: ARR_POP expects array\n");
+        exit(1);
+    }
+    Value out;
+    if (!array_pop(&arr, &out)) {
+        fprintf(stderr, "Runtime error: pop from empty array\n");
+        exit(1);
+    }
+    free_value(arr);
+    push_value(vm, out);
+    break;
+}

src/vm/arrays/arr_push.c

@@ -0,0 +1,16 @@
+case OP_ARR_PUSH: {
+    Value v = pop_value(vm);
+    Value arr = pop_value(vm);
+    if (arr.type != VAL_ARRAY) {
+        fprintf(stderr, "Runtime type error: ARR_PUSH expects array\n");
+        exit(1);
+    }
+    int n = array_push(&arr, v);
+    if (n < 0) {
+        fprintf(stderr, "Runtime error: push failed (OOM?)\n");
+        exit(1);
+    }
+    free_value(arr);
+    push_value(vm, make_int(n));
+    break;
+}

src/vm/arrays/arr_remove.c

@@ -0,0 +1,17 @@
+case OP_ARR_REMOVE: {
+    Value idx = pop_value(vm);
+    Value arr = pop_value(vm);
+    if (arr.type != VAL_ARRAY || idx.type != VAL_INT) {
+        fprintf(stderr, "Runtime type error: ARR_REMOVE expects (array, int)\n");
+        exit(1);
+    }
+    Value out;
+    if (!array_remove(&arr, (int)idx.i, &out)) {
+        fprintf(stderr, "Runtime error: remove index out of range\n");
+        exit(1);
+    }
+    free_value(arr);
+    free_value(idx);
+    push_value(vm, out);
+    break;
+}

src/vm/arrays/arr_set.c

@@ -0,0 +1,19 @@
+case OP_ARR_SET: {
+    Value v = pop_value(vm);
+    Value idx = pop_value(vm);
+    Value arr = pop_value(vm);
+    if (arr.type != VAL_ARRAY || idx.type != VAL_INT) {
+        fprintf(stderr, "Runtime type error: ARR_SET expects (array, int, value)\n");
+        exit(1);
+    }
+    if (!array_set(&arr, (int)idx.i, v)) {
+        fprintf(stderr, "Runtime error: set index out of range\n");
+        exit(1);
+    }
+    free_value(arr);
+    free_value(idx);
+    /* v already owned by array; push copy for return value */
+    push_value(vm, copy_value(&v));
+    free_value(v);
+    break;
+}

src/vm/arrays/clear.c

@@ -0,0 +1,11 @@
+case OP_CLEAR: {
+    Value arr = pop_value(vm);
+    if (arr.type != VAL_ARRAY) {
+        fprintf(stderr, "Runtime type error: CLEAR expects array\n");
+        exit(1);
+    }
+    array_clear(&arr);
+    free_value(arr);
+    push_value(vm, make_int(0));
+    break;
+}

src/vm/arrays/contains.c

@@ -0,0 +1,13 @@
+case OP_CONTAINS: {
+    Value needle = pop_value(vm);
+    Value arr = pop_value(vm);
+    if (arr.type != VAL_ARRAY) {
+        fprintf(stderr, "Runtime type error: CONTAINS expects (array, value)\n");
+        exit(1);
+    }
+    int ok = array_contains(&arr, &needle);
+    free_value(arr);
+    free_value(needle);
+    push_value(vm, make_int(ok ? 1 : 0));
+    break;
+}

src/vm/arrays/enumerate.c

@@ -0,0 +1,11 @@
+case OP_ENUMERATE: {
+    Value arr = pop_value(vm);
+    if (arr.type != VAL_ARRAY) {
+        fprintf(stderr, "Runtime type error: ENUMERATE expects array\n");
+        exit(1);
+    }
+    Value out = bi_enumerate(&arr);
+    free_value(arr);
+    push_value(vm, out);
+    break;
+}

src/vm/arrays/index_get.c

@@ -0,0 +1,31 @@
+case OP_INDEX_GET: {
+    Value idx = pop_value(vm);
+    Value container = pop_value(vm);
+#ifdef FUN_DEBUG
+    fprintf(stderr, "DEBUG INDEX_GET: container.type=%d idx.type=%d\n",
+            container.type, idx.type);
+#endif
+    if (container.type == VAL_ARRAY) {
+        if (idx.type != VAL_INT) { fprintf(stderr, "INDEX_GET index must be int for array\n"); exit(1); }
+        Value elem;
+        if (!array_get_copy(&container, (int)idx.i, &elem)) {
+            fprintf(stderr, "Runtime error: index out of range\n"); exit(1);
+        }
+        free_value(container);
+        free_value(idx);
+        push_value(vm, elem);
+    } else if (container.type == VAL_MAP) {
+        if (idx.type != VAL_STRING) { fprintf(stderr, "INDEX_GET key must be string for map\n"); exit(1); }
+        Value out;
+        if (!map_get_copy(&container, idx.s ? idx.s : "", &out)) {
+            out = make_nil();
+        }
+        free_value(container);
+        free_value(idx);
+        push_value(vm, out);
+    } else {
+        fprintf(stderr, "Runtime type error: INDEX_GET expects array or map\n");
+        exit(1);
+    }
+    break;
+}

src/vm/arrays/index_of.c

@@ -0,0 +1,13 @@
+case OP_INDEX_OF: {
+    Value needle = pop_value(vm);
+    Value arr = pop_value(vm);
+    if (arr.type != VAL_ARRAY) {
+        fprintf(stderr, "Runtime type error: INDEX_OF expects (array, value)\n");
+        exit(1);
+    }
+    int idx = array_index_of(&arr, &needle);
+    free_value(arr);
+    free_value(needle);
+    push_value(vm, make_int(idx));
+    break;
+}

src/vm/arrays/index_set.c

@@ -0,0 +1,28 @@
+case OP_INDEX_SET: {
+    Value v = pop_value(vm);
+    Value idx = pop_value(vm);
+    Value container = pop_value(vm);
+#ifdef FUN_DEBUG
+    fprintf(stderr, "DEBUG INDEX_SET: container.type=%d idx.type=%d value.type=%d\n",
+            container.type, idx.type, v.type);
+#endif
+    if (container.type == VAL_ARRAY) {
+        if (idx.type != VAL_INT) { fprintf(stderr, "INDEX_SET index must be int for array\n"); exit(1); }
+        if (!array_set(&container, (int)idx.i, v)) {
+            fprintf(stderr, "Runtime error: index out of range\n"); exit(1);
+        }
+        free_value(container);
+        free_value(idx);
+    } else if (container.type == VAL_MAP) {
+        if (idx.type != VAL_STRING) { fprintf(stderr, "INDEX_SET key must be string for map\n"); exit(1); }
+        if (!map_set(&container, idx.s ? idx.s : "", v)) {
+            fprintf(stderr, "Runtime error: map set failed\n"); exit(1);
+        }
+        free_value(container);
+        free_value(idx);
+    } else {
+        fprintf(stderr, "Runtime type error: INDEX_SET expects array or map\n");
+        exit(1);
+    }
+    break;
+}

src/vm/arrays/join.c

@@ -0,0 +1,13 @@
+case OP_JOIN: {
+    Value sep = pop_value(vm);
+    Value arr = pop_value(vm);
+    if (arr.type != VAL_ARRAY || sep.type != VAL_STRING) {
+        fprintf(stderr, "Runtime type error: JOIN expects (array, string)\n");
+        exit(1);
+    }
+    Value out = bi_join(&arr, &sep);
+    free_value(arr);
+    free_value(sep);
+    push_value(vm, out);
+    break;
+}

src/vm/arrays/make_array.c

@@ -0,0 +1,21 @@
+case OP_MAKE_ARRAY: {
+    int n = inst.operand;
+    if (n < 0 || vm->sp + 1 < n) {
+        fprintf(stderr, "Runtime error: invalid element count for MAKE_ARRAY\n");
+        exit(1);
+    }
+    /* pop n values into temp array preserving original order */
+    Value *vals = (Value*)malloc(sizeof(Value) * n);
+    if (!vals) { fprintf(stderr, "Runtime error: OOM in MAKE_ARRAY\n"); exit(1); }
+    for (int i = n - 1; i >= 0; --i) {
+        vals[i] = pop_value(vm); /* take ownership */
+    }
+    /* build array by copying values, then free originals */
+    Value arr = make_array_from_values(vals, n);
+    for (int i = 0; i < n; ++i) {
+        free_value(vals[i]);
+    }
+    free(vals);
+    push_value(vm, arr);
+    break;
+}

src/vm/arrays/slice.c

@@ -0,0 +1,15 @@
+case OP_SLICE: {
+    Value end = pop_value(vm);
+    Value start = pop_value(vm);
+    Value arr = pop_value(vm);
+    if (arr.type != VAL_ARRAY || start.type != VAL_INT || end.type != VAL_INT) {
+        fprintf(stderr, "Runtime type error: SLICE expects (array, int, int)\n");
+        exit(1);
+    }
+    Value out = array_slice(&arr, (int)start.i, (int)end.i);
+    free_value(arr);
+    free_value(start);
+    free_value(end);
+    push_value(vm, out);
+    break;
+}

src/vm/arrays/zip.c

@@ -0,0 +1,13 @@
+case OP_ZIP: {
+    Value b = pop_value(vm);
+    Value a = pop_value(vm);
+    if (a.type != VAL_ARRAY || b.type != VAL_ARRAY) {
+        fprintf(stderr, "Runtime type error: ZIP expects (array, array)\n");
+        exit(1);
+    }
+    Value out = bi_zip(&a, &b);
+    free_value(a);
+    free_value(b);
+    push_value(vm, out);
+    break;
+}