tranfi 0.1.2 → 0.2.0

package/csrc/op_registry.c

@@ -1,7 +1,6 @@
 /*
  * op_registry.c — Declarative registry of all built-in ops.
  *
- * Replaces the hard-coded strcmp chain in plan.c.
  * Each entry describes an op's kind, capabilities, arguments,
  * schema inference callback, and native constructor.
  */
@@ -10,18 +9,97 @@
 #include "internal.h"
 #include "cJSON.h"
 #include <string.h>
+#include <strings.h>
+#include <stdio.h>
 #include <stdlib.h>
 
 /* ---- Schema inference callbacks ---- */
 
-/* Decoders: output schema unknown until runtime */
-static int infer_schema_unknown(const tf_ir_node *node,
-                                const tf_schema *in, tf_schema *out) {
-    (void)node; (void)in;
+static void registry_schema_unknown(tf_schema *out) {
+    if (!out) return;
+    tf_schema_free(out);
     out->col_names = NULL;
     out->col_types = NULL;
     out->n_cols = 0;
     out->known = false;
+}
+
+static int registry_schema_alloc_known(tf_schema *out, size_t n_cols) {
+    if (!out) return TF_ERROR;
+    tf_schema_free(out);
+    size_t alloc_n = n_cols ? n_cols : 1;
+    out->col_names = calloc(alloc_n, sizeof(char *));
+    out->col_types = calloc(alloc_n, sizeof(tf_type));
+    if (!out->col_names || !out->col_types) {
+        tf_schema_free(out);
+        return TF_ERROR;
+    }
+    out->n_cols = n_cols;
+    out->known = true;
+    return TF_OK;
+}
+
+static int registry_schema_set_col(tf_schema *out, size_t idx,
+                                   const char *name, tf_type type) {
+    if (!out || !out->known || idx >= out->n_cols || !name) return TF_ERROR;
+    char *copy = strdup(name);
+    if (!copy) return TF_ERROR;
+    free(out->col_names[idx]);
+    out->col_names[idx] = copy;
+    out->col_types[idx] = type;
+    return TF_OK;
+}
+
+static int registry_schema_take_col(tf_schema *out, size_t idx,
+                                    char *name, tf_type type) {
+    if (!out || !out->known || idx >= out->n_cols || !name) {
+        free(name);
+        return TF_ERROR;
+    }
+    free(out->col_names[idx]);
+    out->col_names[idx] = name;
+    out->col_types[idx] = type;
+    return TF_OK;
+}
+
+static void registry_set_schema_error(const char *op, const char *detail) {
+    char buf[512];
+    snprintf(buf, sizeof(buf), "%s schema: %s",
+             op ? op : "op", (detail && detail[0]) ? detail : "schema inference failed");
+    tf_set_last_error(buf);
+}
+
+static int registry_schema_copy_input_columns(tf_schema *out, const tf_schema *in) {
+    if (!out || !in || !out->known || !in->known || out->n_cols < in->n_cols) return TF_ERROR;
+    for (size_t i = 0; i < in->n_cols; i++) {
+        if (registry_schema_set_col(out, i, in->col_names[i] ? in->col_names[i] : "",
+                                    in->col_types[i]) != TF_OK) {
+            tf_schema_free(out);
+            return TF_ERROR;
+        }
+    }
+    return TF_OK;
+}
+
+static int registry_schema_copy_input_plus(tf_schema *out, const tf_schema *in,
+                                           size_t n_extra) {
+    if (!in || !in->known) {
+        registry_schema_unknown(out);
+        return TF_OK;
+    }
+    size_t total = 0;
+    if (tf_size_add(in->n_cols, n_extra, &total) != TF_OK ||
+        registry_schema_alloc_known(out, total) != TF_OK) {
+        return TF_ERROR;
+    }
+    return registry_schema_copy_input_columns(out, in);
+}
+
+/* Decoders: output schema unknown until runtime */
+static int infer_schema_unknown(const tf_ir_node *node,
+                                const tf_schema *in, tf_schema *out) {
+    (void)node; (void)in;
+    registry_schema_unknown(out);
     return TF_OK;
 }
 
@@ -29,10 +107,7 @@ static int infer_schema_unknown(const tf_ir_node *node,
 static int infer_schema_sink(const tf_ir_node *node,
                              const tf_schema *in, tf_schema *out) {
     (void)node; (void)in;
-    out->col_names = NULL;
-    out->col_types = NULL;
-    out->n_cols = 0;
-    out->known = false;
+    registry_schema_unknown(out);
     return TF_OK;
 }
 
@@ -41,35 +116,53 @@ static int infer_schema_passthrough(const tf_ir_node *node,
                                     const tf_schema *in, tf_schema *out) {
     (void)node;
     if (!in->known) {
-        out->known = false;
-        out->col_names = NULL;
-        out->col_types = NULL;
-        out->n_cols = 0;
+        registry_schema_unknown(out);
         return TF_OK;
     }
-    tf_schema_copy(out, in);
-    return TF_OK;
+    return tf_schema_copy_checked(out, in);
 }
 
 /* select: output schema = subset of input columns */
 static int infer_schema_select(const tf_ir_node *node,
                                const tf_schema *in, tf_schema *out) {
     if (!in->known) {
-        out->known = false;
-        out->col_names = NULL;
-        out->col_types = NULL;
-        out->n_cols = 0;
+        registry_schema_unknown(out);
         return TF_OK;
     }
 
     cJSON *cols = cJSON_GetObjectItemCaseSensitive(node->args, "columns");
     if (!cols || !cJSON_IsArray(cols)) return TF_ERROR;
 
+    if (tf_column_selectors_have_syntax_json(cols)) {
+        int *indices = NULL;
+        size_t n_indices = 0;
+        char *error = NULL;
+        int rc = tf_column_selectors_resolve_json(cols, in->col_names, in->col_types, in->n_cols,
+                                                  &indices, &n_indices, &error);
+        if (rc != TF_OK) {
+            registry_set_schema_error("select", error);
+            free(error);
+            return TF_ERROR;
+        }
+        free(error);
+        if (registry_schema_alloc_known(out, n_indices) != TF_OK) {
+            free(indices);
+            return TF_ERROR;
+        }
+        for (size_t i = 0; i < n_indices; i++) {
+            int ci = indices[i];
+            if (registry_schema_set_col(out, i, in->col_names[ci], in->col_types[ci]) != TF_OK) {
+                free(indices);
+                tf_schema_free(out);
+                return TF_ERROR;
+            }
+        }
+        free(indices);
+        return TF_OK;
+    }
+
     int n = cJSON_GetArraySize(cols);
-    out->col_names = calloc(n, sizeof(char *));
-    out->col_types = calloc(n, sizeof(tf_type));
-    out->n_cols = n;
-    out->known = true;
+    if (n < 0 || registry_schema_alloc_known(out, (size_t)n) != TF_OK) return TF_ERROR;
 
     for (int i = 0; i < n; i++) {
         cJSON *item = cJSON_GetArrayItem(cols, i);
@@ -82,18 +175,125 @@ static int infer_schema_select(const tf_ir_node *node,
         bool found = false;
         for (size_t j = 0; j < in->n_cols; j++) {
             if (strcmp(in->col_names[j], name) == 0) {
-                out->col_names[i] = strdup(name);
-                out->col_types[i] = in->col_types[j];
+                if (registry_schema_set_col(out, (size_t)i, name, in->col_types[j]) != TF_OK) {
+                    tf_schema_free(out);
+                    return TF_ERROR;
+                }
                 found = true;
                 break;
             }
         }
         if (!found) {
             /* Column not in input — still record it, validation can catch it */
-            out->col_names[i] = strdup(name);
-            out->col_types[i] = TF_TYPE_NULL;
+            if (registry_schema_set_col(out, (size_t)i, name, TF_TYPE_NULL) != TF_OK) {
+                tf_schema_free(out);
+                return TF_ERROR;
+            }
+        }
+    }
+    return TF_OK;
+}
+
+static int infer_schema_relocate(const tf_ir_node *node,
+                                 const tf_schema *in, tf_schema *out) {
+    if (!in->known) {
+        registry_schema_unknown(out);
+        return TF_OK;
+    }
+
+    cJSON *cols = cJSON_GetObjectItemCaseSensitive(node->args, "columns");
+    if (!cols || !cJSON_IsArray(cols)) return TF_ERROR;
+    cJSON *before = cJSON_GetObjectItemCaseSensitive(node->args, "before");
+    cJSON *after = cJSON_GetObjectItemCaseSensitive(node->args, "after");
+    if (before && after) return TF_ERROR;
+    if (before && !cJSON_IsString(before)) return TF_ERROR;
+    if (after && !cJSON_IsString(after)) return TF_ERROR;
+
+    size_t n_in = in->n_cols;
+    int *move_idx = NULL;
+    size_t n_move = 0;
+    char *selector_error = NULL;
+    int rc = tf_column_selectors_resolve_json(cols, in->col_names, in->col_types, in->n_cols,
+                                              &move_idx, &n_move, &selector_error);
+    if (rc != TF_OK) {
+        registry_set_schema_error("relocate", selector_error);
+        free(selector_error);
+        return TF_ERROR;
+    }
+    free(selector_error);
+
+    int *is_moving = calloc(n_in ? n_in : 1, sizeof(int));
+    int *order = malloc(n_in ? n_in * sizeof(int) : sizeof(int));
+    if (!is_moving || !order) {
+        free(move_idx); free(is_moving); free(order);
+        return TF_ERROR;
+    }
+
+    for (size_t i = 0; i < n_move; i++) {
+        int found = move_idx[i];
+        if (found < 0 || (size_t)found >= n_in || is_moving[found]) {
+            free(move_idx); free(is_moving); free(order);
+            return TF_ERROR;
+        }
+        is_moving[found] = 1;
+    }
+
+    const char *anchor = before ? before->valuestring : (after ? after->valuestring : NULL);
+    int anchor_idx = -1;
+    if (anchor) {
+        for (size_t i = 0; i < n_in; i++) {
+            if (strcmp(in->col_names[i], anchor) == 0) {
+                anchor_idx = (int)i;
+                break;
+            }
+        }
+        if (anchor_idx < 0 || is_moving[anchor_idx]) {
+            free(move_idx); free(is_moving); free(order);
+            return TF_ERROR;
+        }
+    }
+
+    size_t n_order = 0;
+    if (!anchor) {
+        for (size_t i = 0; i < n_move; i++) order[n_order++] = move_idx[i];
+        for (size_t i = 0; i < n_in; i++)
+            if (!is_moving[i]) order[n_order++] = (int)i;
+    } else {
+        for (size_t i = 0; i < n_in; i++) {
+            if (is_moving[i]) continue;
+            if (before && (int)i == anchor_idx) {
+                for (size_t j = 0; j < n_move; j++) order[n_order++] = move_idx[j];
+            }
+            order[n_order++] = (int)i;
+            if (after && (int)i == anchor_idx) {
+                for (size_t j = 0; j < n_move; j++) order[n_order++] = move_idx[j];
+            }
+        }
+    }
+
+    if (n_order != n_in) {
+        free(move_idx); free(is_moving); free(order);
+        return TF_ERROR;
+    }
+
+    if (registry_schema_alloc_known(out, n_in) != TF_OK) {
+        free(move_idx); free(is_moving); free(order);
+        return TF_ERROR;
+    }
+    for (size_t i = 0; i < n_in; i++) {
+        int ci = order[i];
+        if (registry_schema_set_col(out, i, in->col_names[ci], in->col_types[ci]) != TF_OK) {
+            free(move_idx);
+            free(is_moving);
+            free(order);
+            tf_schema_free(out);
+            return TF_ERROR;
         }
     }
+
+    free(move_idx);
+    free(is_moving);
+    free(order);
     return TF_OK;
 }
 
@@ -101,14 +301,11 @@ static int infer_schema_select(const tf_ir_node *node,
 static int infer_schema_rename(const tf_ir_node *node,
                                const tf_schema *in, tf_schema *out) {
     if (!in->known) {
-        out->known = false;
-        out->col_names = NULL;
-        out->col_types = NULL;
-        out->n_cols = 0;
+        registry_schema_unknown(out);
         return TF_OK;
     }
 
-    tf_schema_copy(out, in);
+    if (tf_schema_copy_checked(out, in) != TF_OK) return TF_ERROR;
 
     cJSON *mapping = cJSON_GetObjectItemCaseSensitive(node->args, "mapping");
     if (!mapping || !cJSON_IsObject(mapping)) return TF_OK; /* no renames */
@@ -120,8 +317,10 @@ static int infer_schema_rename(const tf_ir_node *node,
         const char *new_name = entry->valuestring;
         for (size_t i = 0; i < out->n_cols; i++) {
             if (strcmp(out->col_names[i], old_name) == 0) {
-                free(out->col_names[i]);
-                out->col_names[i] = strdup(new_name);
+                if (registry_schema_set_col(out, i, new_name, out->col_types[i]) != TF_OK) {
+                    tf_schema_free(out);
+                    return TF_ERROR;
+                }
                 break;
             }
         }
@@ -133,35 +332,177 @@ static int infer_schema_rename(const tf_ir_node *node,
 static int infer_schema_derive(const tf_ir_node *node,
                                const tf_schema *in, tf_schema *out) {
     if (!in->known) {
-        out->known = false;
-        out->col_names = NULL;
-        out->col_types = NULL;
-        out->n_cols = 0;
+        registry_schema_unknown(out);
         return TF_OK;
     }
 
     cJSON *columns = cJSON_GetObjectItemCaseSensitive(node->args, "columns");
     int n_derived = columns ? cJSON_GetArraySize(columns) : 0;
-    size_t total = in->n_cols + n_derived;
-
-    out->col_names = calloc(total, sizeof(char *));
-    out->col_types = calloc(total, sizeof(tf_type));
-    out->n_cols = total;
-    out->known = true;
-
-    /* Copy input columns */
-    for (size_t i = 0; i < in->n_cols; i++) {
-        out->col_names[i] = strdup(in->col_names[i]);
-        out->col_types[i] = in->col_types[i];
+    if (n_derived < 0 ||
+        registry_schema_copy_input_plus(out, in, (size_t)n_derived) != TF_OK) {
+        return TF_ERROR;
     }
 
     /* Add derived columns (type unknown at compile time) */
     for (int i = 0; i < n_derived; i++) {
         cJSON *item = cJSON_GetArrayItem(columns, i);
         cJSON *name_j = cJSON_GetObjectItemCaseSensitive(item, "name");
-        out->col_names[in->n_cols + i] = strdup(name_j ? name_j->valuestring : "?");
-        out->col_types[in->n_cols + i] = TF_TYPE_NULL;
+        const char *name = cJSON_IsString(name_j) ? name_j->valuestring : "?";
+        if (registry_schema_set_col(out, in->n_cols + (size_t)i, name, TF_TYPE_NULL) != TF_OK) {
+            tf_schema_free(out);
+            return TF_ERROR;
+        }
+    }
+    return TF_OK;
+}
+
+
+static int registry_across_token_matches(const char *p, const char *tok) {
+    return strncmp(p, tok, strlen(tok)) == 0;
+}
+
+static char *registry_across_format_name(const char *tmpl, const char *col, const char *fn) {
+    if (!tmpl || !tmpl[0]) tmpl = "{col}_{fn}";
+    if (!col) col = "";
+    if (!fn) fn = "";
+    size_t len = 0;
+    for (const char *p = tmpl; *p;) {
+        if (registry_across_token_matches(p, "{.col}")) { len += strlen(col); p += 6; }
+        else if (registry_across_token_matches(p, "{col}")) { len += strlen(col); p += 5; }
+        else if (registry_across_token_matches(p, "{.fn}")) { len += strlen(fn); p += 5; }
+        else if (registry_across_token_matches(p, "{fn}")) { len += strlen(fn); p += 4; }
+        else { len++; p++; }
+    }
+    char *out = malloc(len + 1);
+    if (!out) return NULL;
+    char *w = out;
+    for (const char *p = tmpl; *p;) {
+        const char *rep = NULL;
+        size_t tok_len = 0;
+        if (registry_across_token_matches(p, "{.col}")) { rep = col; tok_len = 6; }
+        else if (registry_across_token_matches(p, "{col}")) { rep = col; tok_len = 5; }
+        else if (registry_across_token_matches(p, "{.fn}")) { rep = fn; tok_len = 5; }
+        else if (registry_across_token_matches(p, "{fn}")) { rep = fn; tok_len = 4; }
+        if (rep) {
+            size_t n = strlen(rep);
+            memcpy(w, rep, n);
+            w += n;
+            p += tok_len;
+        } else {
+            *w++ = *p++;
+        }
+    }
+    *w = '\0';
+    return out;
+}
+
+static tf_type registry_across_output_type(const char *fn, tf_type input) {
+    if (!fn) return TF_TYPE_NULL;
+    if (strcasecmp(fn, "trim") == 0 || strcasecmp(fn, "lower") == 0 ||
+        strcasecmp(fn, "tolower") == 0 || strcasecmp(fn, "upper") == 0 ||
+        strcasecmp(fn, "toupper") == 0) {
+        return input == TF_TYPE_STRING ? TF_TYPE_STRING : TF_TYPE_NULL;
     }
+    if (!(input == TF_TYPE_INT64 || input == TF_TYPE_FLOAT64)) return TF_TYPE_NULL;
+    if (strcasecmp(fn, "abs") == 0) return input;
+    if (strcasecmp(fn, "round") == 0 || strcasecmp(fn, "floor") == 0 ||
+        strcasecmp(fn, "ceil") == 0 || strcasecmp(fn, "ceiling") == 0) return TF_TYPE_INT64;
+    if (strcasecmp(fn, "sqrt") == 0 || strcasecmp(fn, "log") == 0 ||
+        strcasecmp(fn, "exp") == 0) return TF_TYPE_FLOAT64;
+    return TF_TYPE_NULL;
+}
+
+static int registry_across_functions(const tf_ir_node *node, cJSON **out_fns, int *out_n) {
+    cJSON *functions = cJSON_GetObjectItemCaseSensitive(node->args, "functions");
+    if (!functions) functions = cJSON_GetObjectItemCaseSensitive(node->args, "fns");
+    cJSON *fn = cJSON_GetObjectItemCaseSensitive(node->args, "fn");
+    if (cJSON_IsArray(functions)) {
+        int n = cJSON_GetArraySize(functions);
+        if (n <= 0) return TF_ERROR;
+        *out_fns = functions;
+        *out_n = n;
+        return TF_OK;
+    }
+    if (cJSON_IsString(functions) || cJSON_IsString(fn)) {
+        *out_fns = cJSON_IsString(functions) ? functions : fn;
+        *out_n = 1;
+        return TF_OK;
+    }
+    return TF_ERROR;
+}
+
+/* across: input schema with selected columns replaced, or input + generated columns */
+static int infer_schema_across(const tf_ir_node *node,
+                               const tf_schema *in, tf_schema *out) {
+    if (!in->known) {
+        registry_schema_unknown(out);
+        return TF_OK;
+    }
+
+    cJSON *cols = cJSON_GetObjectItemCaseSensitive(node->args, "columns");
+    if (!cols || !cJSON_IsArray(cols)) return TF_ERROR;
+    int *indices = NULL;
+    size_t n_indices = 0;
+    char *error = NULL;
+    int rc = tf_column_selectors_resolve_json(cols, in->col_names, in->col_types, in->n_cols,
+                                              &indices, &n_indices, &error);
+    if (rc != TF_OK) {
+        registry_set_schema_error("across", error);
+        free(error);
+        return TF_ERROR;
+    }
+    free(error);
+
+    cJSON *fns = NULL;
+    int n_fns = 0;
+    if (registry_across_functions(node, &fns, &n_fns) != TF_OK) { free(indices); return TF_ERROR; }
+    cJSON *names = cJSON_GetObjectItemCaseSensitive(node->args, "names");
+    cJSON *replace_j = cJSON_GetObjectItemCaseSensitive(node->args, "replace");
+    int replace = cJSON_IsBool(replace_j) ? cJSON_IsTrue(replace_j) : (n_fns == 1 && !cJSON_IsString(names));
+    if (replace && n_fns != 1) { free(indices); return TF_ERROR; }
+    const char *tmpl = cJSON_IsString(names) ? names->valuestring : (replace ? "{col}" : "{col}_{fn}");
+
+    size_t extra = 0;
+    size_t total = 0;
+    if (!replace && tf_size_mul(n_indices, (size_t)n_fns, &extra) != TF_OK) {
+        free(indices);
+        return TF_ERROR;
+    }
+    if (tf_size_add(in->n_cols, extra, &total) != TF_OK ||
+        registry_schema_alloc_known(out, total) != TF_OK ||
+        registry_schema_copy_input_columns(out, in) != TF_OK) {
+        free(indices);
+        return TF_ERROR;
+    }
+
+    if (replace) {
+        const char *fn_name = cJSON_IsArray(fns) ? cJSON_GetArrayItem(fns, 0)->valuestring : fns->valuestring;
+        for (size_t i = 0; i < n_indices; i++) {
+            size_t ci = (size_t)indices[i];
+            tf_type t = registry_across_output_type(fn_name, in->col_types[ci]);
+            if (t == TF_TYPE_NULL) { free(indices); tf_schema_free(out); return TF_ERROR; }
+            out->col_types[ci] = t;
+        }
+    } else {
+        size_t a = 0;
+        for (size_t i = 0; i < n_indices; i++) {
+            size_t ci = (size_t)indices[i];
+            for (int f = 0; f < n_fns; f++) {
+                cJSON *fn_j = cJSON_IsArray(fns) ? cJSON_GetArrayItem(fns, f) : fns;
+                if (!cJSON_IsString(fn_j)) { free(indices); tf_schema_free(out); return TF_ERROR; }
+                tf_type t = registry_across_output_type(fn_j->valuestring, in->col_types[ci]);
+                if (t == TF_TYPE_NULL) { free(indices); tf_schema_free(out); return TF_ERROR; }
+                char *name = registry_across_format_name(tmpl, in->col_names[ci], fn_j->valuestring);
+                if (registry_schema_take_col(out, in->n_cols + a, name, t) != TF_OK) {
+                    free(indices);
+                    tf_schema_free(out);
+                    return TF_ERROR;
+                }
+                a++;
+            }
+        }
+    }
+    free(indices);
     return TF_OK;
 }
 
@@ -169,17 +510,80 @@ static int infer_schema_derive(const tf_ir_node *node,
 static int infer_schema_validate(const tf_ir_node *node,
                                  const tf_schema *in, tf_schema *out) {
     (void)node;
-    if (!in->known) { out->known = false; out->col_names = NULL; out->col_types = NULL; out->n_cols = 0; return TF_OK; }
-    out->n_cols = in->n_cols + 1;
-    out->col_names = calloc(out->n_cols, sizeof(char *));
-    out->col_types = calloc(out->n_cols, sizeof(tf_type));
-    out->known = true;
-    for (size_t i = 0; i < in->n_cols; i++) {
-        out->col_names[i] = strdup(in->col_names[i]);
-        out->col_types[i] = in->col_types[i];
+    if (!in->known) { registry_schema_unknown(out); return TF_OK; }
+    if (registry_schema_copy_input_plus(out, in, 1) != TF_OK) return TF_ERROR;
+    if (registry_schema_set_col(out, in->n_cols, "_valid", TF_TYPE_BOOL) != TF_OK) {
+        tf_schema_free(out);
+        return TF_ERROR;
+    }
+    return TF_OK;
+}
+
+static int infer_schema_assert(const tf_ir_node *node,
+                               const tf_schema *in, tf_schema *out) {
+    cJSON *action_j = cJSON_GetObjectItemCaseSensitive(node->args, "action");
+    const char *action = cJSON_IsString(action_j) ? action_j->valuestring : "fail";
+    if (strcmp(action, "annotate") != 0) return infer_schema_passthrough(node, in, out);
+    if (!in->known) { registry_schema_unknown(out); return TF_OK; }
+    cJSON *result_j = cJSON_GetObjectItemCaseSensitive(node->args, "result");
+    const char *result = cJSON_IsString(result_j) && result_j->valuestring[0]
+        ? result_j->valuestring : "_assert";
+    if (registry_schema_copy_input_plus(out, in, 1) != TF_OK) return TF_ERROR;
+    if (registry_schema_set_col(out, in->n_cols, result, TF_TYPE_BOOL) != TF_OK) {
+        tf_schema_free(out);
+        return TF_ERROR;
+    }
+    return TF_OK;
+}
+
+static int infer_schema_schema(const tf_ir_node *node,
+                               const tf_schema *in, tf_schema *out) {
+    cJSON *action_j = cJSON_GetObjectItemCaseSensitive(node->args, "action");
+    cJSON *mode_j = cJSON_GetObjectItemCaseSensitive(node->args, "mode");
+    const char *action = cJSON_IsString(action_j) ? action_j->valuestring :
+        (cJSON_IsString(mode_j) ? mode_j->valuestring : "fail");
+    if (strcmp(action, "annotate") != 0) return infer_schema_passthrough(node, in, out);
+    if (!in->known) { registry_schema_unknown(out); return TF_OK; }
+    cJSON *result_j = cJSON_GetObjectItemCaseSensitive(node->args, "result");
+    const char *result = cJSON_IsString(result_j) && result_j->valuestring[0]
+        ? result_j->valuestring : "_schema";
+    if (registry_schema_copy_input_plus(out, in, 1) != TF_OK) return TF_ERROR;
+    if (registry_schema_set_col(out, in->n_cols, result, TF_TYPE_BOOL) != TF_OK) {
+        tf_schema_free(out);
+        return TF_ERROR;
+    }
+    return TF_OK;
+}
+
+static int infer_schema_schema_infer(const tf_ir_node *node,
+                                     const tf_schema *in, tf_schema *out) {
+    (void)node; (void)in;
+    static const char *names[] = {
+        "column", "type", "nullable", "non_null", "rows_seen",
+        "rows_sampled", "missing", "non_missing", "observed_types", "warning"
+    };
+    static const tf_type types[] = {
+        TF_TYPE_STRING, TF_TYPE_STRING, TF_TYPE_BOOL, TF_TYPE_BOOL, TF_TYPE_INT64,
+        TF_TYPE_INT64, TF_TYPE_INT64, TF_TYPE_INT64, TF_TYPE_STRING, TF_TYPE_STRING
+    };
+    size_t n = sizeof(names) / sizeof(names[0]);
+    if (registry_schema_alloc_known(out, n) != TF_OK) return TF_ERROR;
+    for (size_t i = 0; i < n; i++) {
+        if (registry_schema_set_col(out, i, names[i], types[i]) != TF_OK) {
+            tf_schema_free(out);
+            return TF_ERROR;
+        }
+    }
+    return TF_OK;
+}
+
+static int infer_schema_add_int64_column(const tf_schema *in, tf_schema *out, const char *name) {
+    if (!in->known) { registry_schema_unknown(out); return TF_OK; }
+    if (registry_schema_copy_input_plus(out, in, 1) != TF_OK) return TF_ERROR;
+    if (registry_schema_set_col(out, in->n_cols, name, TF_TYPE_INT64) != TF_OK) {
+        tf_schema_free(out);
+        return TF_ERROR;
     }
-    out->col_names[in->n_cols] = strdup("_valid");
-    out->col_types[in->n_cols] = TF_TYPE_BOOL;
     return TF_OK;
 }
 
@@ -187,17 +591,42 @@ static int infer_schema_validate(const tf_ir_node *node,
 static int infer_schema_add_hash(const tf_ir_node *node,
                                  const tf_schema *in, tf_schema *out) {
     (void)node;
-    if (!in->known) { out->known = false; out->col_names = NULL; out->col_types = NULL; out->n_cols = 0; return TF_OK; }
-    out->n_cols = in->n_cols + 1;
-    out->col_names = calloc(out->n_cols, sizeof(char *));
-    out->col_types = calloc(out->n_cols, sizeof(tf_type));
-    out->known = true;
-    for (size_t i = 0; i < in->n_cols; i++) {
-        out->col_names[i] = strdup(in->col_names[i]);
-        out->col_types[i] = in->col_types[i];
+    return infer_schema_add_int64_column(in, out, "_hash");
+}
+
+static int infer_schema_rleid(const tf_ir_node *node,
+                              const tf_schema *in, tf_schema *out) {
+    const char *name = "_rleid";
+    cJSON *res = cJSON_GetObjectItemCaseSensitive(node->args, "result");
+    if (cJSON_IsString(res) && res->valuestring[0] != '\0') name = res->valuestring;
+    return infer_schema_add_int64_column(in, out, name);
+}
+
+static int infer_schema_rowid(const tf_ir_node *node,
+                              const tf_schema *in, tf_schema *out) {
+    const char *name = "_rowid";
+    cJSON *res = cJSON_GetObjectItemCaseSensitive(node->args, "result");
+    if (cJSON_IsString(res) && res->valuestring[0] != '\0') name = res->valuestring;
+    return infer_schema_add_int64_column(in, out, name);
+}
+
+static int infer_schema_source_name(const tf_ir_node *node,
+                                    const tf_schema *in, tf_schema *out) {
+    if (!in->known) {
+        registry_schema_unknown(out);
+        return TF_OK;
+    }
+    const char *name = "_source";
+    cJSON *res = cJSON_GetObjectItemCaseSensitive(node->args, "result");
+    if (!cJSON_IsString(res)) res = cJSON_GetObjectItemCaseSensitive(node->args, "column");
+    if (!cJSON_IsString(res)) res = cJSON_GetObjectItemCaseSensitive(node->args, "as");
+    if (cJSON_IsString(res) && res->valuestring[0] != '\0') name = res->valuestring;
+
+    if (registry_schema_copy_input_plus(out, in, 1) != TF_OK) return TF_ERROR;
+    if (registry_schema_set_col(out, in->n_cols, name, TF_TYPE_STRING) != TF_OK) {
+        tf_schema_free(out);
+        return TF_ERROR;
     }
-    out->col_names[in->n_cols] = strdup("_hash");
-    out->col_types[in->n_cols] = TF_TYPE_INT64;
     return TF_OK;
 }
 
@@ -205,74 +634,382 @@ static int infer_schema_add_hash(const tf_ir_node *node,
 static int infer_schema_frequency(const tf_ir_node *node,
                                   const tf_schema *in, tf_schema *out) {
     (void)node; (void)in;
-    out->n_cols = 2;
-    out->col_names = calloc(2, sizeof(char *));
-    out->col_types = calloc(2, sizeof(tf_type));
-    out->known = true;
-    out->col_names[0] = strdup("value");
-    out->col_types[0] = TF_TYPE_STRING;
-    out->col_names[1] = strdup("count");
-    out->col_types[1] = TF_TYPE_INT64;
+    if (registry_schema_alloc_known(out, 2) != TF_OK) return TF_ERROR;
+    if (registry_schema_set_col(out, 0, "value", TF_TYPE_STRING) != TF_OK ||
+        registry_schema_set_col(out, 1, "count", TF_TYPE_INT64) != TF_OK) {
+        tf_schema_free(out);
+        return TF_ERROR;
+    }
     return TF_OK;
 }
 
-/* group-agg: group columns (string) + agg columns (float64) */
+static int schema_col_index(const tf_schema *schema, const char *name);
+
+static int infer_schema_pivot(const tf_ir_node *node,
+                              const tf_schema *in, tf_schema *out) {
+    if (!node || !node->args || !in || !in->known) {
+        registry_schema_unknown(out);
+        return TF_OK;
+    }
+
+    cJSON *cats = cJSON_GetObjectItemCaseSensitive(node->args, "categories");
+    if (!cats) {
+        registry_schema_unknown(out);
+        return TF_OK;
+    }
+    if (!cJSON_IsArray(cats)) {
+        registry_set_schema_error("pivot", "categories must be an array");
+        return TF_ERROR;
+    }
+
+    cJSON *name_j = cJSON_GetObjectItemCaseSensitive(node->args, "name_column");
+    cJSON *value_j = cJSON_GetObjectItemCaseSensitive(node->args, "value_column");
+    const char *name_col = cJSON_IsString(name_j) ? name_j->valuestring : NULL;
+    const char *value_col = cJSON_IsString(value_j) ? value_j->valuestring : NULL;
+    if (!name_col || !name_col[0] || !value_col || !value_col[0]) {
+        registry_set_schema_error("pivot", "missing name_column or value_column");
+        return TF_ERROR;
+    }
+
+    int name_idx = schema_col_index(in, name_col);
+    int value_idx = schema_col_index(in, value_col);
+    if (name_idx < 0 || value_idx < 0) {
+        registry_set_schema_error("pivot", "name_column or value_column not found");
+        return TF_ERROR;
+    }
+
+    int n_cats = cJSON_GetArraySize(cats);
+    if (n_cats <= 0) {
+        registry_set_schema_error("pivot", "categories cannot be empty");
+        return TF_ERROR;
+    }
+
+    size_t unique_cats = 0;
+    for (int i = 0; i < n_cats; i++) {
+        cJSON *cat = cJSON_GetArrayItem(cats, i);
+        if (!cJSON_IsString(cat) || !cat->valuestring || !cat->valuestring[0]) {
+            registry_set_schema_error("pivot", "categories must be non-empty strings");
+            return TF_ERROR;
+        }
+        int seen = 0;
+        for (int j = 0; j < i; j++) {
+            cJSON *prev = cJSON_GetArrayItem(cats, j);
+            if (cJSON_IsString(prev) && prev->valuestring &&
+                strcmp(prev->valuestring, cat->valuestring) == 0) {
+                seen = 1;
+                break;
+            }
+        }
+        if (!seen) {
+            size_t next_unique = 0;
+            if (tf_size_add(unique_cats, 1, &next_unique) != TF_OK) return TF_ERROR;
+            unique_cats = next_unique;
+        }
+    }
+
+    size_t n_pass = 0;
+    for (size_t c = 0; c < in->n_cols; c++) {
+        if ((int)c != name_idx && (int)c != value_idx) n_pass++;
+    }
+    size_t total = 0;
+    if (tf_size_add(n_pass, unique_cats, &total) != TF_OK ||
+        registry_schema_alloc_known(out, total) != TF_OK) {
+        return TF_ERROR;
+    }
+
+    size_t out_idx = 0;
+    for (size_t c = 0; c < in->n_cols; c++) {
+        if ((int)c == name_idx || (int)c == value_idx) continue;
+        if (registry_schema_set_col(out, out_idx++, in->col_names[c] ? in->col_names[c] : "",
+                                    in->col_types[c]) != TF_OK) {
+            tf_schema_free(out);
+            return TF_ERROR;
+        }
+    }
+
+    cJSON *agg_j = cJSON_GetObjectItemCaseSensitive(node->args, "agg");
+    const char *agg = cJSON_IsString(agg_j) ? agg_j->valuestring : NULL;
+    tf_type pivot_type = (agg && strcmp(agg, "count") == 0) ? TF_TYPE_INT64 : TF_TYPE_FLOAT64;
+    for (int i = 0; i < n_cats; i++) {
+        cJSON *cat = cJSON_GetArrayItem(cats, i);
+        int seen = 0;
+        for (int j = 0; j < i; j++) {
+            cJSON *prev = cJSON_GetArrayItem(cats, j);
+            if (cJSON_IsString(prev) && prev->valuestring &&
+                strcmp(prev->valuestring, cat->valuestring) == 0) {
+                seen = 1;
+                break;
+            }
+        }
+        if (seen) continue;
+        if (registry_schema_set_col(out, out_idx++, cat->valuestring, pivot_type) != TF_OK) {
+            tf_schema_free(out);
+            return TF_ERROR;
+        }
+    }
+    return TF_OK;
+}
+
+static int schema_col_index(const tf_schema *schema, const char *name) {
+    if (!schema || !schema->known || !name) return -1;
+    for (size_t i = 0; i < schema->n_cols; i++) {
+        if (schema->col_names[i] && strcmp(schema->col_names[i], name) == 0) return (int)i;
+    }
+    return -1;
+}
+
+
+static int infer_schema_append_source_column(const tf_ir_node *node,
+                                             const tf_schema *in,
+                                             tf_schema *out,
+                                             const char *default_suffix) {
+    cJSON *col_j = cJSON_GetObjectItemCaseSensitive(node->args, "column");
+    const char *column = cJSON_IsString(col_j) ? col_j->valuestring : NULL;
+    if (!in->known || !column) {
+        registry_schema_unknown(out);
+        return TF_OK;
+    }
+
+    int ci = schema_col_index(in, column);
+    if (ci < 0) {
+        registry_schema_unknown(out);
+        return TF_OK;
+    }
+
+    const char *name = NULL;
+    cJSON *res = cJSON_GetObjectItemCaseSensitive(node->args, "result");
+    if (cJSON_IsString(res) && res->valuestring[0] != '\0') name = res->valuestring;
+
+    char fallback[256];
+    if (!name) {
+        snprintf(fallback, sizeof(fallback), "%s_%s", column, default_suffix);
+        name = fallback;
+    }
+
+    if (registry_schema_copy_input_plus(out, in, 1) != TF_OK) return TF_ERROR;
+    if (registry_schema_set_col(out, in->n_cols, name, in->col_types[ci]) != TF_OK) {
+        tf_schema_free(out);
+        return TF_ERROR;
+    }
+    return TF_OK;
+}
+
+static int infer_schema_lead(const tf_ir_node *node,
+                             const tf_schema *in, tf_schema *out) {
+    return infer_schema_append_source_column(node, in, out, "lead");
+}
+
+static int infer_schema_lag(const tf_ir_node *node,
+                            const tf_schema *in, tf_schema *out) {
+    return infer_schema_append_source_column(node, in, out, "lag");
+}
+
+static int infer_schema_shift(const tf_ir_node *node,
+                              const tf_schema *in, tf_schema *out) {
+    const char *suffix = "shift";
+    cJSON *type = cJSON_GetObjectItemCaseSensitive(node->args, "type");
+    if (cJSON_IsString(type) && strcmp(type->valuestring, "lead") == 0) suffix = "lead";
+    return infer_schema_append_source_column(node, in, out, suffix);
+}
+
+static tf_type json_extract_type_from_arg(const cJSON *args) {
+    cJSON *type = cJSON_GetObjectItemCaseSensitive(args, "type");
+    const char *s = cJSON_IsString(type) ? type->valuestring : "string";
+    if (strcmp(s, "int") == 0 || strcmp(s, "int64") == 0) return TF_TYPE_INT64;
+    if (strcmp(s, "float") == 0 || strcmp(s, "float64") == 0 || strcmp(s, "number") == 0) return TF_TYPE_FLOAT64;
+    if (strcmp(s, "bool") == 0 || strcmp(s, "boolean") == 0) return TF_TYPE_BOOL;
+    return TF_TYPE_STRING;
+}
+
+static int infer_schema_json_extract(const tf_ir_node *node,
+                                     const tf_schema *in, tf_schema *out) {
+    if (!in->known) {
+        registry_schema_unknown(out);
+        return TF_OK;
+    }
+
+    cJSON *res = cJSON_GetObjectItemCaseSensitive(node->args, "result");
+    if (!cJSON_IsString(res) || res->valuestring[0] == '\0') return TF_ERROR;
+
+    if (registry_schema_copy_input_plus(out, in, 1) != TF_OK) return TF_ERROR;
+    if (registry_schema_set_col(out, in->n_cols, res->valuestring,
+                                json_extract_type_from_arg(node->args)) != TF_OK) {
+        tf_schema_free(out);
+        return TF_ERROR;
+    }
+    return TF_OK;
+}
+
+static int infer_schema_json_schema(const tf_ir_node *node,
+                                    const tf_schema *in, tf_schema *out) {
+    cJSON *mode_j = cJSON_GetObjectItemCaseSensitive(node->args, "mode");
+    const char *mode = cJSON_IsString(mode_j) ? mode_j->valuestring : "annotate";
+    if (strcmp(mode, "filter") == 0 || strcmp(mode, "keep") == 0) {
+        return infer_schema_passthrough(node, in, out);
+    }
+
+    if (!in->known) {
+        registry_schema_unknown(out);
+        return TF_OK;
+    }
+
+    const char *result = "_valid";
+    cJSON *res = cJSON_GetObjectItemCaseSensitive(node->args, "result");
+    if (cJSON_IsString(res) && res->valuestring[0] != '\0') result = res->valuestring;
+
+    if (registry_schema_copy_input_plus(out, in, 1) != TF_OK) return TF_ERROR;
+    if (registry_schema_set_col(out, in->n_cols, result, TF_TYPE_BOOL) != TF_OK) {
+        tf_schema_free(out);
+        return TF_ERROR;
+    }
+    return TF_OK;
+}
+
+static tf_type json_flatten_type_from_string(const char *type_s) {
+    if (!type_s || strcmp(type_s, "string") == 0 || strcmp(type_s, "str") == 0 || strcmp(type_s, "json") == 0) return TF_TYPE_STRING;
+    if (strcmp(type_s, "int") == 0 || strcmp(type_s, "int64") == 0) return TF_TYPE_INT64;
+    if (strcmp(type_s, "float") == 0 || strcmp(type_s, "float64") == 0 || strcmp(type_s, "number") == 0) return TF_TYPE_FLOAT64;
+    if (strcmp(type_s, "bool") == 0 || strcmp(type_s, "boolean") == 0) return TF_TYPE_BOOL;
+    return TF_TYPE_NULL;
+}
+
+static int json_flatten_parse_string_field(const char *spec, char **name, tf_type *type) {
+    if (!spec) return TF_ERROR;
+    char *copy = strdup(spec);
+    if (!copy) return TF_ERROR;
+    char *first = strchr(copy, ':');
+    if (!first) { free(copy); return TF_ERROR; }
+    *first = '\0';
+    char *second = strchr(first + 1, ':');
+    if (second) *second = '\0';
+    tf_type parsed = json_flatten_type_from_string(second ? second + 1 : "string");
+    if (first[1] == '\0' || parsed == TF_TYPE_NULL) {
+        free(copy);
+        return TF_ERROR;
+    }
+    *name = strdup(first + 1);
+    *type = parsed;
+    free(copy);
+    return *name ? TF_OK : TF_ERROR;
+}
+
+static int json_flatten_field_schema(const cJSON *item, char **name, tf_type *type) {
+    *name = NULL;
+    *type = TF_TYPE_STRING;
+    if (cJSON_IsString(item)) return json_flatten_parse_string_field(item->valuestring, name, type);
+    if (!cJSON_IsObject(item)) return TF_ERROR;
+    cJSON *name_j = cJSON_GetObjectItemCaseSensitive(item, "name");
+    if (!cJSON_IsString(name_j)) name_j = cJSON_GetObjectItemCaseSensitive(item, "result");
+    cJSON *type_j = cJSON_GetObjectItemCaseSensitive(item, "type");
+    tf_type parsed = json_flatten_type_from_string(cJSON_IsString(type_j) ? type_j->valuestring : "string");
+    if (!cJSON_IsString(name_j) || name_j->valuestring[0] == '\0' || parsed == TF_TYPE_NULL) return TF_ERROR;
+    *name = strdup(name_j->valuestring);
+    *type = parsed;
+    return *name ? TF_OK : TF_ERROR;
+}
+
+static int infer_schema_json_flatten(const tf_ir_node *node,
+                                     const tf_schema *in, tf_schema *out) {
+    if (!in->known) {
+        registry_schema_unknown(out);
+        return TF_OK;
+    }
+    cJSON *fields = cJSON_GetObjectItemCaseSensitive(node->args, "fields");
+    if (!cJSON_IsArray(fields) || cJSON_GetArraySize(fields) <= 0) return TF_ERROR;
+    int n_fields = cJSON_GetArraySize(fields);
+    if (registry_schema_copy_input_plus(out, in, (size_t)n_fields) != TF_OK) return TF_ERROR;
+    for (int i = 0; i < n_fields; i++) {
+        char *name = NULL;
+        tf_type type = TF_TYPE_STRING;
+        if (json_flatten_field_schema(cJSON_GetArrayItem(fields, i), &name, &type) != TF_OK) {
+            free(name);
+            tf_schema_free(out);
+            return TF_ERROR;
+        }
+        if (registry_schema_take_col(out, in->n_cols + (size_t)i, name, type) != TF_OK) {
+            tf_schema_free(out);
+            return TF_ERROR;
+        }
+    }
+    return TF_OK;
+}
+
+
+/* group-agg: typed group columns + aggregate columns (float64) */
 static int infer_schema_group_agg(const tf_ir_node *node,
                                   const tf_schema *in, tf_schema *out) {
-    (void)in;
     cJSON *group_by = cJSON_GetObjectItemCaseSensitive(node->args, "group_by");
     cJSON *aggs = cJSON_GetObjectItemCaseSensitive(node->args, "aggs");
     int ng = group_by ? cJSON_GetArraySize(group_by) : 0;
     int na = aggs ? cJSON_GetArraySize(aggs) : 0;
-    out->n_cols = ng + na;
-    out->col_names = calloc(out->n_cols, sizeof(char *));
-    out->col_types = calloc(out->n_cols, sizeof(tf_type));
-    out->known = true;
+    if (ng < 0 || na < 0) return TF_ERROR;
+    size_t total = 0;
+    if (tf_size_add((size_t)ng, (size_t)na, &total) != TF_OK ||
+        registry_schema_alloc_known(out, total) != TF_OK) return TF_ERROR;
     for (int i = 0; i < ng; i++) {
         cJSON *item = cJSON_GetArrayItem(group_by, i);
-        out->col_names[i] = strdup(cJSON_IsString(item) ? item->valuestring : "?");
-        out->col_types[i] = TF_TYPE_STRING;
+        const char *name = cJSON_IsString(item) ? item->valuestring : "?";
+        int input_idx = schema_col_index(in, name);
+        tf_type type = input_idx >= 0 ? in->col_types[input_idx] : TF_TYPE_STRING;
+        if (registry_schema_set_col(out, (size_t)i, name, type) != TF_OK) {
+            tf_schema_free(out);
+            return TF_ERROR;
+        }
     }
     for (int i = 0; i < na; i++) {
         cJSON *item = cJSON_GetArrayItem(aggs, i);
         cJSON *name_j = cJSON_GetObjectItemCaseSensitive(item, "name");
-        out->col_names[ng + i] = strdup(name_j && cJSON_IsString(name_j) ? name_j->valuestring : "?");
-        out->col_types[ng + i] = TF_TYPE_FLOAT64;
+        const char *name = name_j && cJSON_IsString(name_j) ? name_j->valuestring : "?";
+        if (registry_schema_set_col(out, (size_t)ng + (size_t)i, name, TF_TYPE_FLOAT64) != TF_OK) {
+            tf_schema_free(out);
+            return TF_ERROR;
+        }
     }
     return TF_OK;
 }
 
-/* stats: output schema is known: column, count, sum, avg, min, max */
+/* stats/scan: output schema is known from requested or profile-default stats */
 static int infer_schema_stats(const tf_ir_node *node,
                               const tf_schema *in, tf_schema *out) {
     (void)in;
-    /* Determine which stats are requested */
-    int w_count=0, w_sum=0, w_avg=0, w_min=0, w_max=0;
-    int w_var=0, w_stddev=0, w_median=0, w_p25=0, w_p75=0;
-    int w_skewness=0, w_kurtosis=0, w_distinct=0, w_hist=0, w_sample=0;
-    cJSON *stats_arr = cJSON_GetObjectItemCaseSensitive(node->args, "stats");
-    if (stats_arr && cJSON_IsArray(stats_arr)) {
-        int n = cJSON_GetArraySize(stats_arr);
+    int w_count = 0, w_missing = 0, w_complete_rate = 0;
+    int w_sum = 0, w_avg = 0, w_min = 0, w_max = 0;
+    int w_var = 0, w_stddev = 0;
+    int w_median = 0, w_p25 = 0, w_p75 = 0;
+    int w_skewness = 0, w_kurtosis = 0;
+    int w_distinct = 0, w_hist = 0, w_sample = 0;
+
+    cJSON *arr = node ? cJSON_GetObjectItemCaseSensitive(node->args, "stats") : NULL;
+    if (arr && cJSON_IsArray(arr)) {
+        int n = cJSON_GetArraySize(arr);
         for (int i = 0; i < n; i++) {
-            cJSON *item = cJSON_GetArrayItem(stats_arr, i);
+            cJSON *item = cJSON_GetArrayItem(arr, i);
             if (!cJSON_IsString(item)) continue;
             const char *s = item->valuestring;
             if (strcmp(s, "count") == 0) w_count = 1;
+            else if (strcmp(s, "missing") == 0) w_missing = 1;
+            else if (strcmp(s, "complete_rate") == 0) w_complete_rate = 1;
             else if (strcmp(s, "sum") == 0) w_sum = 1;
-            else if (strcmp(s, "avg") == 0) w_avg = 1;
+            else if (strcmp(s, "avg") == 0 || strcmp(s, "mean") == 0) w_avg = 1;
             else if (strcmp(s, "min") == 0) w_min = 1;
             else if (strcmp(s, "max") == 0) w_max = 1;
-            else if (strcmp(s, "var") == 0) w_var = 1;
-            else if (strcmp(s, "stddev") == 0) w_stddev = 1;
+            else if (strcmp(s, "var") == 0 || strcmp(s, "variance") == 0) w_var = 1;
+            else if (strcmp(s, "stddev") == 0 || strcmp(s, "sd") == 0) w_stddev = 1;
             else if (strcmp(s, "median") == 0) w_median = 1;
-            else if (strcmp(s, "p25") == 0) w_p25 = 1;
-            else if (strcmp(s, "p75") == 0) w_p75 = 1;
-            else if (strcmp(s, "skewness") == 0) w_skewness = 1;
-            else if (strcmp(s, "kurtosis") == 0) w_kurtosis = 1;
+            else if (strcmp(s, "p25") == 0 || strcmp(s, "q1") == 0) w_p25 = 1;
+            else if (strcmp(s, "p75") == 0 || strcmp(s, "q3") == 0) w_p75 = 1;
+            else if (strcmp(s, "skewness") == 0 || strcmp(s, "skew") == 0) w_skewness = 1;
+            else if (strcmp(s, "kurtosis") == 0 || strcmp(s, "kurt") == 0) w_kurtosis = 1;
             else if (strcmp(s, "distinct") == 0) w_distinct = 1;
             else if (strcmp(s, "hist") == 0) w_hist = 1;
             else if (strcmp(s, "sample") == 0) w_sample = 1;
         }
+    } else if (node && node->op && strcmp(node->op, "scan") == 0) {
+        w_count = w_missing = w_complete_rate = 1;
+        w_distinct = 1;
+        w_min = w_max = w_avg = w_stddev = 1;
+        w_p25 = w_median = w_p75 = 1;
+        w_hist = w_sample = 1;
     } else {
         /* Default: basic + variance + median */
         w_count = w_sum = w_avg = w_min = w_max = 1;
@@ -281,6 +1018,8 @@ static int infer_schema_stats(const tf_ir_node *node,
 
     size_t n_cols = 1; /* column */
     if (w_count) n_cols++;
+    if (w_missing) n_cols++;
+    if (w_complete_rate) n_cols++;
     if (w_sum) n_cols++;
     if (w_avg) n_cols++;
     if (w_min) n_cols++;
@@ -296,28 +1035,37 @@ static int infer_schema_stats(const tf_ir_node *node,
     if (w_hist) n_cols++;
     if (w_sample) n_cols++;
 
-    out->col_names = calloc(n_cols, sizeof(char *));
-    out->col_types = calloc(n_cols, sizeof(tf_type));
-    out->n_cols = n_cols;
-    out->known = true;
+    if (registry_schema_alloc_known(out, n_cols) != TF_OK) return TF_ERROR;
 
     size_t ci = 0;
-    out->col_names[ci] = strdup("column"); out->col_types[ci++] = TF_TYPE_STRING;
-    if (w_count) { out->col_names[ci] = strdup("count"); out->col_types[ci++] = TF_TYPE_INT64; }
-    if (w_sum) { out->col_names[ci] = strdup("sum"); out->col_types[ci++] = TF_TYPE_FLOAT64; }
-    if (w_avg) { out->col_names[ci] = strdup("avg"); out->col_types[ci++] = TF_TYPE_FLOAT64; }
-    if (w_min) { out->col_names[ci] = strdup("min"); out->col_types[ci++] = TF_TYPE_FLOAT64; }
-    if (w_max) { out->col_names[ci] = strdup("max"); out->col_types[ci++] = TF_TYPE_FLOAT64; }
-    if (w_var) { out->col_names[ci] = strdup("var"); out->col_types[ci++] = TF_TYPE_FLOAT64; }
-    if (w_stddev) { out->col_names[ci] = strdup("stddev"); out->col_types[ci++] = TF_TYPE_FLOAT64; }
-    if (w_median) { out->col_names[ci] = strdup("median"); out->col_types[ci++] = TF_TYPE_FLOAT64; }
-    if (w_p25) { out->col_names[ci] = strdup("p25"); out->col_types[ci++] = TF_TYPE_FLOAT64; }
-    if (w_p75) { out->col_names[ci] = strdup("p75"); out->col_types[ci++] = TF_TYPE_FLOAT64; }
-    if (w_skewness) { out->col_names[ci] = strdup("skewness"); out->col_types[ci++] = TF_TYPE_FLOAT64; }
-    if (w_kurtosis) { out->col_names[ci] = strdup("kurtosis"); out->col_types[ci++] = TF_TYPE_FLOAT64; }
-    if (w_distinct) { out->col_names[ci] = strdup("distinct"); out->col_types[ci++] = TF_TYPE_INT64; }
-    if (w_hist) { out->col_names[ci] = strdup("hist"); out->col_types[ci++] = TF_TYPE_STRING; }
-    if (w_sample) { out->col_names[ci] = strdup("sample"); out->col_types[ci++] = TF_TYPE_STRING; }
+#define ADD_STAT_COLUMN(name, type) do { \
+        if (registry_schema_set_col(out, ci, (name), (type)) != TF_OK) { \
+            tf_schema_free(out); \
+            return TF_ERROR; \
+        } \
+        ci++; \
+    } while (0)
+
+    ADD_STAT_COLUMN("column", TF_TYPE_STRING);
+    if (w_count)         ADD_STAT_COLUMN("count", TF_TYPE_INT64);
+    if (w_missing)       ADD_STAT_COLUMN("missing", TF_TYPE_INT64);
+    if (w_complete_rate) ADD_STAT_COLUMN("complete_rate", TF_TYPE_FLOAT64);
+    if (w_sum)           ADD_STAT_COLUMN("sum", TF_TYPE_FLOAT64);
+    if (w_avg)           ADD_STAT_COLUMN("avg", TF_TYPE_FLOAT64);
+    if (w_min)           ADD_STAT_COLUMN("min", TF_TYPE_FLOAT64);
+    if (w_max)           ADD_STAT_COLUMN("max", TF_TYPE_FLOAT64);
+    if (w_var)           ADD_STAT_COLUMN("var", TF_TYPE_FLOAT64);
+    if (w_stddev)        ADD_STAT_COLUMN("stddev", TF_TYPE_FLOAT64);
+    if (w_median)        ADD_STAT_COLUMN("median", TF_TYPE_FLOAT64);
+    if (w_p25)           ADD_STAT_COLUMN("p25", TF_TYPE_FLOAT64);
+    if (w_p75)           ADD_STAT_COLUMN("p75", TF_TYPE_FLOAT64);
+    if (w_skewness)      ADD_STAT_COLUMN("skewness", TF_TYPE_FLOAT64);
+    if (w_kurtosis)      ADD_STAT_COLUMN("kurtosis", TF_TYPE_FLOAT64);
+    if (w_distinct)      ADD_STAT_COLUMN("distinct", TF_TYPE_INT64);
+    if (w_hist)          ADD_STAT_COLUMN("hist", TF_TYPE_STRING);
+    if (w_sample)        ADD_STAT_COLUMN("sample", TF_TYPE_STRING);
+#undef ADD_STAT_COLUMN
+
     return TF_OK;
 }
 
@@ -328,6 +1076,22 @@ static tf_arg_desc csv_decode_args[] = {
     {"header",    "bool",   false, "true"},
     {"batch_size","int",    false, "1024"},
     {"repair",    "bool",   false, "false"},
+    {"mode",      "string", false, "permissive"},
+    {"strict",    "bool",   false, "false"},
+    {"max_error_bytes", "int", false, "4096"},
+    {"max_record_bytes", "int", false, "67108864"},
+    {"max_columns", "int", false, "8192"},
+    {"nulls",    "string|array", false, """"},
+    {"na",       "string|array", false, """"},
+    {"quoted_nulls", "bool", false, "true"},
+    {"audit", "bool", false, "false"},
+    {"audit_limit", "int", false, "1000"},
+    {"audit_include_row", "bool", false, "true"},
+    {"audit_columns", "string[]", false, NULL},
+    {"audit_redact", "string[]", false, NULL},
+    {"audit_hash_columns", "string[]", false, NULL},
+    {"audit_max_bytes", "size", false, "0"},
+    {"audit_max_cell_bytes", "size", false, "0"},
 };
 
 static tf_arg_desc csv_encode_args[] = {
@@ -337,6 +1101,10 @@ static tf_arg_desc csv_encode_args[] = {
 
 static tf_arg_desc jsonl_decode_args[] = {
     {"batch_size", "int", false, "1024"},
+    {"on_error", "string", false, "skip"},
+    {"max_error_bytes", "int", false, "4096"},
+    {"max_record_bytes", "int", false, "67108864"},
+    {"max_columns", "int", false, "8192"},
 };
 
 static tf_arg_desc jsonl_encode_args[] = {
@@ -345,6 +1113,9 @@ static tf_arg_desc jsonl_encode_args[] = {
 
 static tf_arg_desc text_decode_args[] = {
     {"batch_size", "int", false, "1024"},
+    {"max_error_bytes", "int", false, "4096"},
+    {"max_record_bytes", "int", false, "67108864"},
+    {"max_columns", "int", false, "8192"},
 };
 
 static tf_arg_desc text_encode_args[] = {
@@ -360,12 +1131,26 @@ static tf_arg_desc grep_args[] = {
 
 static tf_arg_desc filter_args[] = {
     {"expr", "string", true, NULL},
+    {"audit", "bool", false, "false"},
+    {"audit_limit", "int", false, "1000"},
+    {"audit_include_row", "bool", false, "true"},
+    {"audit_columns", "string[]", false, NULL},
+    {"audit_redact", "string[]", false, NULL},
+    {"audit_hash_columns", "string[]", false, NULL},
+    {"audit_max_bytes", "int", false, NULL},
+    {"audit_max_cell_bytes", "int", false, NULL},
 };
 
 static tf_arg_desc select_args[] = {
     {"columns", "string[]", true, NULL},
 };
 
+static tf_arg_desc relocate_args[] = {
+    {"columns", "string[]", true, NULL},
+    {"before", "string", false, NULL},
+    {"after", "string", false, NULL},
+};
+
 static tf_arg_desc rename_args[] = {
     {"mapping", "map", true, NULL},
 };
@@ -382,20 +1167,141 @@ static tf_arg_desc derive_args[] = {
     {"columns", "map[]", true, NULL},
 };
 
+
+static tf_arg_desc across_args[] = {
+    {"columns", "string[]", true, NULL},
+    {"fn", "string", false, NULL},
+    {"functions", "string[]", false, NULL},
+    {"names", "string", false, NULL},
+    {"replace", "bool", false, NULL},
+};
+
 static tf_arg_desc stats_args[] = {
     {"stats", "string[]", false, NULL},
 };
 
+static tf_arg_desc scan_args[] = {
+    {"stats", "string[]", false, NULL},
+};
+
 static tf_arg_desc unique_args[] = {
     {"columns", "string[]", false, NULL},
+    {"max_keys", "int", false, NULL},
+    {"max_state_bytes", "int", false, NULL},
+    {"spill_dir", "string", false, NULL},
+    {"spill_memory_bytes", "int", false, NULL},
+    {"spill_run_rows", "int", false, NULL},
+    {"spill_output_rows", "int", false, NULL},
+    {"sorted", "bool", false, "false"},
+    {"mode", "string", false, "\"exact\""},
+    {"approx", "bool", false, "false"},
+    {"bloom_bytes", "int", false, NULL},
+    {"bloom_hashes", "int", false, "7"},
 };
 
 static tf_arg_desc sort_args[] = {
     {"columns", "map[]", true, NULL},
+    {"spill_dir", "string", false, NULL},
+    {"spill_memory_bytes", "int", false, NULL},
+    {"spill_run_rows", "int", false, NULL},
+    {"spill_output_rows", "int", false, NULL},
 };
 
 static tf_arg_desc validate_args[] = {
+    {"expr", "string", false, NULL},
+    {"rules", "array|object", false, NULL},
+    {"rules_file", "string", false, NULL},
+    {"audit", "bool", false, "false"},
+    {"audit_limit", "int", false, "1000"},
+    {"audit_include_row", "bool", false, "true"},
+    {"audit_columns", "string[]", false, NULL},
+    {"audit_redact", "string[]", false, NULL},
+    {"audit_hash_columns", "string[]", false, NULL},
+    {"audit_max_bytes", "int", false, NULL},
+    {"audit_max_cell_bytes", "int", false, NULL},
+    {"max_failures", "int", false, NULL},
+    {"max_failure_rate", "number", false, NULL},
+    {"warn_failure_rate", "number", false, NULL},
+    {"name", "string", false, "\"validate\""},
+    {"message", "string", false, "\"\""},
+};
+
+static tf_arg_desc assert_args[] = {
+    {"expr", "string", false, NULL},
+    {"aggregate", "string", false, NULL},
+    {"column", "string", false, NULL},
+    {"op", "string", false, NULL},
+    {"value", "number", false, NULL},
+    {"tolerance", "number", false, "1e-12"},
+    {"rel", "bool", false, "true"},
+    {"action", "string", false, "\"fail\""},
+    {"name", "string", false, "\"assert\""},
+    {"message", "string", false, "\"\""},
+    {"result", "string", false, "\"_assert\""},
+    {"audit", "bool", false, "false"},
+    {"audit_limit", "int", false, "1000"},
+    {"audit_include_row", "bool", false, "true"},
+    {"audit_columns", "string[]", false, NULL},
+    {"audit_redact", "string[]", false, NULL},
+    {"audit_hash_columns", "string[]", false, NULL},
+    {"audit_max_bytes", "int", false, NULL},
+    {"audit_max_cell_bytes", "int", false, NULL},
+};
+
+static tf_arg_desc quarantine_args[] = {
     {"expr", "string", true, NULL},
+    {"name", "string", false, "\"quarantine\""},
+    {"message", "string", false, "\"\""},
+    {"audit_include_row", "bool", false, "true"},
+    {"audit_columns", "string[]", false, NULL},
+    {"audit_redact", "string[]", false, NULL},
+    {"audit_hash_columns", "string[]", false, NULL},
+    {"audit_max_bytes", "size", false, "0"},
+    {"audit_max_cell_bytes", "size", false, "0"},
+};
+
+static tf_arg_desc tee_args[] = {
+    {"expr", "string", false, NULL},
+    {"channel", "string", false, "\"samples\""},
+    {"columns", "string[]", false, NULL},
+    {"limit", "int", false, "1000"},
+    {"every", "int", false, "1"},
+    {"name", "string", false, "\"tee\""},
+    {"include_row", "bool", false, "true"},
+    {"audit_include_row", "bool", false, "true"},
+    {"audit_columns", "string[]", false, NULL},
+    {"audit_redact", "string[]", false, NULL},
+    {"audit_hash_columns", "string[]", false, NULL},
+    {"audit_max_bytes", "size", false, "0"},
+    {"audit_max_cell_bytes", "size", false, "0"},
+};
+
+static tf_arg_desc schema_args[] = {
+    {"columns", "map", false, NULL},
+    {"required", "string[]", false, NULL},
+    {"non_null", "string[]", false, NULL},
+    {"nullable", "string[]", false, NULL},
+    {"values", "map", false, NULL},
+    {"min", "map", false, NULL},
+    {"max", "map", false, NULL},
+    {"regex", "map", false, NULL},
+    {"max_regex_pattern_bytes", "int", false, "4096"},
+    {"max_regex_cell_bytes", "int", false, "65536"},
+    {"audit_include_row", "bool", false, "true"},
+    {"audit_columns", "string[]", false, NULL},
+    {"audit_redact", "string[]", false, NULL},
+    {"audit_hash_columns", "string[]", false, NULL},
+    {"audit_max_bytes", "int", false, NULL},
+    {"audit_max_cell_bytes", "int", false, NULL},
+    {"mode", "string", false, "\"fail\""},
+    {"action", "string", false, "\"fail\""},
+    {"name", "string", false, "\"schema\""},
+    {"message", "string", false, "\"\""},
+    {"result", "string", false, "\"_schema\""},
+};
+
+static tf_arg_desc schema_infer_args[] = {
+    {"rows", "int", false, "10000"},
 };
 
 static tf_arg_desc trim_args[] = {
@@ -404,10 +1310,26 @@ static tf_arg_desc trim_args[] = {
 
 static tf_arg_desc fill_null_args[] = {
     {"mapping", "map", true, NULL},
+    {"audit", "bool", false, "false"},
+    {"audit_limit", "int", false, "1000"},
+    {"audit_include_row", "bool", false, "true"},
+    {"audit_columns", "string[]", false, NULL},
+    {"audit_redact", "string[]", false, NULL},
+    {"audit_hash_columns", "string[]", false, NULL},
+    {"audit_max_bytes", "size", false, "0"},
+    {"audit_max_cell_bytes", "size", false, "0"},
 };
 
 static tf_arg_desc cast_args[] = {
     {"mapping", "map", true, NULL},
+    {"audit", "bool", false, "false"},
+    {"audit_limit", "int", false, "1000"},
+    {"audit_include_row", "bool", false, "true"},
+    {"audit_columns", "string[]", false, NULL},
+    {"audit_redact", "string[]", false, NULL},
+    {"audit_hash_columns", "string[]", false, NULL},
+    {"audit_max_bytes", "size", false, "0"},
+    {"audit_max_cell_bytes", "size", false, "0"},
 };
 
 static tf_arg_desc clip_args[] = {
@@ -421,6 +1343,14 @@ static tf_arg_desc replace_args[] = {
     {"pattern", "string", true, NULL},
     {"replacement", "string", true, NULL},
     {"regex", "bool", false, "false"},
+    {"audit", "bool", false, "false"},
+    {"audit_limit", "int", false, "1000"},
+    {"audit_include_row", "bool", false, "true"},
+    {"audit_columns", "string[]", false, NULL},
+    {"audit_redact", "string[]", false, NULL},
+    {"audit_hash_columns", "string[]", false, NULL},
+    {"audit_max_bytes", "size", false, "0"},
+    {"audit_max_cell_bytes", "size", false, "0"},
 };
 
 static tf_arg_desc hash_args[] = {
@@ -430,6 +1360,8 @@ static tf_arg_desc hash_args[] = {
 static tf_arg_desc bin_args[] = {
     {"column", "string", true, NULL},
     {"boundaries", "float[]", true, NULL},
+    {"missing", "string", false, "\"error\""},
+    {"on_type_error", "string", false, "\"fail\""},
 };
 
 static tf_arg_desc fill_down_args[] = {
@@ -440,6 +1372,8 @@ static tf_arg_desc step_args[] = {
     {"column", "string", true, NULL},
     {"func", "string", true, NULL},
     {"result", "string", false, NULL},
+    {"missing", "string", false, "\"error\""},
+    {"on_type_error", "string", false, "\"fail\""},
 };
 
 static tf_arg_desc window_args[] = {
@@ -447,11 +1381,32 @@ static tf_arg_desc window_args[] = {
     {"size", "int", true, NULL},
     {"func", "string", true, NULL},
     {"result", "string", false, NULL},
+    {"missing", "string", false, "\"error\""},
+    {"on_type_error", "string", false, "\"fail\""},
+};
+
+static tf_arg_desc rolling_args[] = {
+    {"column", "string", true, NULL},
+    {"size", "int", true, NULL},
+    {"result", "string", false, NULL},
+    {"missing", "string", false, "\"error\""},
+    {"on_type_error", "string", false, "\"fail\""},
+};
+
+static tf_arg_desc rolling_bool_args[] = {
+    {"column", "string", true, NULL},
+    {"size", "int", true, NULL},
+    {"result", "string", false, NULL},
+    {"nulls", "string", false, "\"ignore\""},
 };
 
 static tf_arg_desc explode_args[] = {
     {"column", "string", true, NULL},
     {"delimiter", "string", false, "\",\""},
+    {"max_tokens_per_row", "int", false, NULL},
+    {"max_output_rows_per_input_row", "int", false, NULL},
+    {"max_output_rows_per_batch", "int", false, NULL},
+    {"max_token_bytes", "int", false, NULL},
 };
 
 static tf_arg_desc split_args[] = {
@@ -462,6 +1417,8 @@ static tf_arg_desc split_args[] = {
 
 static tf_arg_desc unpivot_args[] = {
     {"columns", "string[]", true, NULL},
+    {"max_output_rows_per_input_row", "int", false, NULL},
+    {"max_output_rows_per_batch", "int", false, NULL},
 };
 
 static tf_arg_desc tail_args[] = {
@@ -472,36 +1429,112 @@ static tf_arg_desc top_args[] = {
     {"n", "int", true, NULL},
     {"column", "string", true, NULL},
     {"desc", "bool", false, "true"},
+    {"with_ties", "bool", false, "false"},
 };
 
 static tf_arg_desc sample_args[] = {
     {"n", "int", true, NULL},
+    {"seed", "int|string", false, "0"},
 };
 
 static tf_arg_desc group_agg_args[] = {
     {"group_by", "string[]", true, NULL},
     {"aggs", "map[]", true, NULL},
+    {"max_groups", "int", false, NULL},
+    {"max_state_bytes", "int", false, NULL},
+    {"spill_dir", "string", false, NULL},
+    {"spill_memory_bytes", "int", false, NULL},
+    {"spill_run_rows", "int", false, NULL},
+    {"spill_output_rows", "int", false, NULL},
+    {"sorted", "bool", false, "false"},
 };
 
 static tf_arg_desc frequency_args[] = {
     {"columns", "string[]", false, NULL},
+    {"max_values", "int", false, NULL},
+    {"max_state_bytes", "int", false, NULL},
+    {"overflow", "string", false, "\"error\""},
+    {"other", "string", false, "\"__other__\""},
+    {"audit", "bool", false, "false"},
+    {"audit_limit", "int", false, "1000"},
+    {"audit_include_row", "bool", false, "true"},
+    {"audit_columns", "string[]", false, NULL},
+    {"audit_redact", "string[]", false, NULL},
+    {"audit_hash_columns", "string[]", false, NULL},
+    {"audit_max_bytes", "size", false, "0"},
+    {"audit_max_cell_bytes", "size", false, "0"},
 };
 
 static tf_arg_desc datetime_args[] = {
     {"column", "string", true, NULL},
     {"extract", "string[]", false, NULL},
+    {"missing", "string", false, "\"error\""},
+    {"on_type_error", "string", false, "\"fail\""},
 };
 
 static tf_arg_desc pivot_args[] = {
     {"name_column", "string", true, NULL},
     {"value_column", "string", true, NULL},
     {"agg", "string", false, "\"first\""},
+    {"categories", "array", false, NULL},
+    {"max_categories", "int", false, NULL},
+    {"sorted", "bool", false, "false"},
+    {"spill_dir", "string", false, NULL},
+    {"spill_memory_bytes", "int", false, NULL},
+    {"spill_run_rows", "int", false, NULL},
+    {"spill_output_rows", "int", false, NULL},
 };
 
 static tf_arg_desc join_args[] = {
     {"file", "string", true, NULL},
     {"on", "string", true, NULL},
     {"how", "string", false, "\"inner\""},
+    {"max_lookup_rows", "int", false, NULL},
+    {"max_lookup_keys", "int", false, NULL},
+    {"max_lookup_bytes", "int", false, NULL},
+    {"max_state_bytes", "int", false, NULL},
+    {"max_matches_per_row", "int", false, NULL},
+    {"max_output_rows", "int", false, NULL},
+    {"spill_dir", "string", false, NULL},
+    {"spill_memory_bytes", "int", false, NULL},
+    {"spill_run_rows", "int", false, NULL},
+    {"spill_output_rows", "int", false, NULL},
+    {"sorted", "bool", false, "false"},
+};
+
+static tf_arg_desc set_file_args[] = {
+    {"file", "string", true, NULL},
+    {"columns", "string[]", false, NULL},
+    {"max_lookup_rows", "int", false, NULL},
+    {"max_lookup_keys", "int", false, NULL},
+    {"max_lookup_bytes", "int", false, NULL},
+    {"max_output_keys", "int", false, NULL},
+    {"max_state_bytes", "int", false, NULL},
+    {"spill_dir", "string", false, NULL},
+    {"spill_memory_bytes", "int", false, NULL},
+    {"spill_run_rows", "int", false, NULL},
+    {"spill_output_rows", "int", false, NULL},
+    {"sorted", "bool", false, "false"},
+};
+
+static tf_arg_desc union_args[] = {
+    {"file", "string", true, NULL},
+    {"columns", "string[]", false, NULL},
+    {"max_lookup_rows", "int", false, NULL},
+    {"max_lookup_bytes", "int", false, NULL},
+    {"max_output_keys", "int", false, NULL},
+    {"max_state_bytes", "int", false, NULL},
+    {"spill_dir", "string", false, NULL},
+    {"spill_memory_bytes", "int", false, NULL},
+    {"spill_run_rows", "int", false, NULL},
+    {"spill_output_rows", "int", false, NULL},
+    {"sorted", "bool", false, "false"},
+};
+
+static tf_arg_desc union_all_args[] = {
+    {"file", "string", true, NULL},
+    {"max_lookup_rows", "int", false, NULL},
+    {"max_lookup_bytes", "int", false, NULL},
 };
 
 static tf_arg_desc stack_args[] = {
@@ -516,38 +1549,80 @@ static tf_arg_desc lead_args[] = {
     {"result", "string", false, NULL},
 };
 
+static tf_arg_desc lag_args[] = {
+    {"column", "string", true, NULL},
+    {"offset", "int", false, "1"},
+    {"result", "string", false, NULL},
+};
+
+static tf_arg_desc shift_args[] = {
+    {"column", "string", true, NULL},
+    {"offset", "int", false, "1"},
+    {"result", "string", false, NULL},
+    {"type", "string", false, "\"lag\""},
+};
+
+static tf_arg_desc rowid_args[] = {
+    {"columns", "string[]", false, NULL},
+    {"result", "string", false, "\"_rowid\""},
+    {"sorted", "bool", false, "false"},
+    {"max_keys", "int", false, NULL},
+    {"max_state_bytes", "int", false, NULL},
+};
+
+static tf_arg_desc rleid_args[] = {
+    {"columns", "string[]", true, NULL},
+    {"result", "string", false, "\"_rleid\""},
+};
+
 static tf_arg_desc date_trunc_args[] = {
     {"column", "string", true, NULL},
     {"trunc", "string", true, NULL},
     {"result", "string", false, NULL},
+    {"missing", "string", false, "\"error\""},
+    {"on_type_error", "string", false, "\"fail\""},
 };
 
 static tf_arg_desc onehot_args[] = {
     {"column", "string", true, NULL},
     {"drop", "bool", false, "false"},
+    {"categories", "array", false, NULL},
+    {"max_categories", "int", false, NULL},
+    {"max_state_bytes", "int", false, NULL},
+    {"unknown", "string", false, NULL},
 };
 
 static tf_arg_desc label_encode_args[] = {
     {"column", "string", true, NULL},
     {"result", "string", false, NULL},
+    {"categories", "array", false, NULL},
+    {"max_categories", "int", false, NULL},
+    {"max_state_bytes", "int", false, NULL},
+    {"unknown", "string", false, NULL},
 };
 
 static tf_arg_desc ewma_args[] = {
     {"column", "string", true, NULL},
     {"alpha", "float", true, NULL},
     {"result", "string", false, NULL},
+    {"missing", "string", false, "\"error\""},
+    {"on_type_error", "string", false, "\"fail\""},
 };
 
 static tf_arg_desc diff_args[] = {
     {"column", "string", true, NULL},
     {"order", "int", false, "1"},
     {"result", "string", false, NULL},
+    {"missing", "string", false, "\"error\""},
+    {"on_type_error", "string", false, "\"fail\""},
 };
 
 static tf_arg_desc anomaly_args[] = {
     {"column", "string", true, NULL},
     {"threshold", "float", false, "3.0"},
     {"result", "string", false, NULL},
+    {"missing", "string", false, "\"error\""},
+    {"on_type_error", "string", false, "\"fail\""},
 };
 
 static tf_arg_desc split_data_args[] = {
@@ -556,19 +1631,73 @@ static tf_arg_desc split_data_args[] = {
     {"seed", "int", false, "42"},
 };
 
+static tf_arg_desc source_name_args[] = {
+    {"result", "string", false, "\"_source\""},
+    {"default", "string", false, "\"\""},
+};
+
 static tf_arg_desc interpolate_args[] = {
     {"column", "string", true, NULL},
     {"method", "string", false, "\"linear\""},
+    {"missing", "string", false, "\"error\""},
+    {"on_type_error", "string", false, "\"fail\""},
 };
 
 static tf_arg_desc normalize_args[] = {
     {"columns", "string[]", true, NULL},
     {"method", "string", false, "\"minmax\""},
+    {"missing", "string", false, "\"error\""},
+    {"on_type_error", "string", false, "\"fail\""},
+    {"audit", "bool", false, "false"},
+    {"audit_limit", "int", false, "1000"},
+    {"audit_include_row", "bool", false, "true"},
+    {"audit_columns", "string[]", false, NULL},
+    {"audit_redact", "string[]", false, NULL},
+    {"audit_hash_columns", "string[]", false, NULL},
+    {"audit_max_bytes", "size", false, "0"},
+    {"audit_max_cell_bytes", "size", false, "0"},
 };
 
 static tf_arg_desc acf_args[] = {
     {"column", "string", true, NULL},
     {"lags", "int", false, "20"},
+    {"missing", "string", false, "\"error\""},
+    {"on_type_error", "string", false, "\"fail\""},
+};
+
+static tf_arg_desc json_extract_args[] = {
+    {"column", "string", false, "\"_line\""},
+    {"path", "string", true, NULL},
+    {"result", "string", true, NULL},
+    {"type", "string", false, "\"string\""},
+};
+
+static tf_arg_desc json_filter_args[] = {
+    {"column", "string", false, "\"_line\""},
+    {"path", "string", true, NULL},
+    {"op", "string", false, "\"exists\""},
+    {"value", "string", false, NULL},
+    {"type", "string", false, "\"auto\""},
+};
+
+static tf_arg_desc json_schema_args[] = {
+    {"column", "string", false, "\"_line\""},
+    {"schema", "object|string|bool", true, NULL},
+    {"mode", "string", false, "\"annotate\""},
+    {"result", "string", false, "\"_valid\""},
+    {"audit", "bool", false, "false"},
+    {"audit_limit", "int", false, "1000"},
+    {"audit_include_row", "bool", false, "true"},
+    {"audit_columns", "string[]", false, NULL},
+    {"audit_redact", "string[]", false, NULL},
+    {"audit_hash_columns", "string[]", false, NULL},
+    {"audit_max_bytes", "int", false, NULL},
+    {"audit_max_cell_bytes", "int", false, NULL},
+};
+
+static tf_arg_desc json_flatten_args[] = {
+    {"column", "string", false, "\"_line\""},
+    {"fields", "object[]|string[]", true, NULL},
 };
 
 static tf_arg_desc table_encode_args[] = {
@@ -576,14 +1705,49 @@ static tf_arg_desc table_encode_args[] = {
     {"max_rows", "int", false, "0"},
 };
 
+
+const char *tf_memory_class_name(tf_memory_class cls) {
+    switch (cls) {
+        case TF_MEM_ROW_LOCAL: return "row_local";
+        case TF_MEM_BOUNDED_STATE: return "bounded_state";
+        case TF_MEM_KEY_STATE: return "key_state";
+        case TF_MEM_BLOCKING: return "blocking";
+        case TF_MEM_EXTERNAL: return "external";
+        default: return "unknown";
+    }
+}
+
+const char *tf_emit_class_name(tf_emit_class cls) {
+    switch (cls) {
+        case TF_EMIT_PER_BATCH: return "per_batch";
+        case TF_EMIT_ON_FLUSH: return "on_flush";
+        case TF_EMIT_SIDE_ONLY: return "side_only";
+        case TF_EMIT_MIXED: return "mixed";
+        default: return "unknown";
+    }
+}
+
+const char *tf_schema_class_name(tf_schema_class cls) {
+    switch (cls) {
+        case TF_SCHEMA_STABLE: return "stable";
+        case TF_SCHEMA_PARAMETRIC: return "parametric";
+        case TF_SCHEMA_DATA_DEPENDENT: return "data_dependent";
+        default: return "unknown";
+    }
+}
+
 static tf_op_entry builtin_ops[] = {
     {
         .name = "codec.csv.decode",
         .kind = TF_OP_DECODER,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_BOUNDED_STATE,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_DATA_DEPENDENT,
+        .state_estimate = "O(batch_size * columns)",
         .args = csv_decode_args,
-        .n_args = 4,
+        .n_args = 20,
         .infer_schema = infer_schema_unknown,
         .create_native = (void *(*)(const cJSON *))tf_csv_decoder_create,
     },
@@ -592,6 +1756,10 @@ static tf_op_entry builtin_ops[] = {
         .kind = TF_OP_ENCODER,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_BOUNDED_STATE,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_STABLE,
+        .state_estimate = "O(output_chunk)",
         .args = csv_encode_args,
         .n_args = 2,
         .infer_schema = infer_schema_sink,
@@ -602,8 +1770,12 @@ static tf_op_entry builtin_ops[] = {
         .kind = TF_OP_DECODER,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_BOUNDED_STATE,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_DATA_DEPENDENT,
+        .state_estimate = "O(batch_size)",
         .args = jsonl_decode_args,
-        .n_args = 1,
+        .n_args = 3,
         .infer_schema = infer_schema_unknown,
         .create_native = (void *(*)(const cJSON *))tf_jsonl_decoder_create,
     },
@@ -612,6 +1784,10 @@ static tf_op_entry builtin_ops[] = {
         .kind = TF_OP_ENCODER,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_BOUNDED_STATE,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_STABLE,
+        .state_estimate = "O(output_chunk)",
         .args = jsonl_encode_args,
         .n_args = 0,
         .infer_schema = infer_schema_sink,
@@ -622,6 +1798,10 @@ static tf_op_entry builtin_ops[] = {
         .kind = TF_OP_DECODER,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_BOUNDED_STATE,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(batch_size)",
         .args = text_decode_args,
         .n_args = 1,
         .infer_schema = infer_schema_unknown,
@@ -632,6 +1812,10 @@ static tf_op_entry builtin_ops[] = {
         .kind = TF_OP_ENCODER,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_BOUNDED_STATE,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_STABLE,
+        .state_estimate = "O(output_chunk)",
         .args = text_encode_args,
         .n_args = 0,
         .infer_schema = infer_schema_sink,
@@ -642,6 +1826,10 @@ static tf_op_entry builtin_ops[] = {
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_ROW_LOCAL,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_STABLE,
+        .state_estimate = "O(batch_rows)",
         .args = grep_args,
         .n_args = 4,
         .infer_schema = infer_schema_passthrough,
@@ -652,8 +1840,12 @@ static tf_op_entry builtin_ops[] = {
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_ROW_LOCAL,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_STABLE,
+        .state_estimate = "O(batch_rows * columns)",
         .args = filter_args,
-        .n_args = 1,
+        .n_args = 9,
         .infer_schema = infer_schema_passthrough,
         .create_native = (void *(*)(const cJSON *))tf_filter_create,
     },
@@ -662,6 +1854,10 @@ static tf_op_entry builtin_ops[] = {
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_ROW_LOCAL,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(batch_rows * selected_columns)",
         .args = select_args,
         .n_args = 1,
         .infer_schema = infer_schema_select,
@@ -672,6 +1868,10 @@ static tf_op_entry builtin_ops[] = {
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_ROW_LOCAL,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(columns)",
         .args = rename_args,
         .n_args = 1,
         .infer_schema = infer_schema_rename,
@@ -682,48 +1882,126 @@ static tf_op_entry builtin_ops[] = {
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_BOUNDED_STATE,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_STABLE,
+        .state_estimate = "O(1)",
         .args = head_args,
         .n_args = 1,
         .infer_schema = infer_schema_passthrough,
         .create_native = (void *(*)(const cJSON *))tf_head_create,
     },
     {
-        .name = "skip",
+        .name = "slice-head",
+        .kind = TF_OP_TRANSFORM,
+        .tier = TF_TIER_CORE,
+        .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_BOUNDED_STATE,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_STABLE,
+        .state_estimate = "O(1)",
+        .args = head_args,
+        .n_args = 1,
+        .infer_schema = infer_schema_passthrough,
+        .create_native = (void *(*)(const cJSON *))tf_head_create,
+    },
+    {
+        .name = "skip",
+        .kind = TF_OP_TRANSFORM,
+        .tier = TF_TIER_CORE,
+        .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_BOUNDED_STATE,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_STABLE,
+        .state_estimate = "O(1)",
+        .args = skip_args,
+        .n_args = 1,
+        .infer_schema = infer_schema_passthrough,
+        .create_native = (void *(*)(const cJSON *))tf_skip_create,
+    },
+    {
+        .name = "derive",
+        .kind = TF_OP_TRANSFORM,
+        .tier = TF_TIER_CORE,
+        .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_ROW_LOCAL,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(batch_rows * derived_columns)",
+        .args = derive_args,
+        .n_args = 1,
+        .infer_schema = infer_schema_derive,
+        .create_native = (void *(*)(const cJSON *))tf_derive_create,
+    },
+
+    {
+        .name = "source-name",
+        .kind = TF_OP_TRANSFORM,
+        .tier = TF_TIER_CORE,
+        .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_ROW_LOCAL,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(batch_rows)",
+        .args = source_name_args,
+        .n_args = 2,
+        .infer_schema = infer_schema_source_name,
+        .create_native = (void *(*)(const cJSON *))tf_source_name_create,
+    },
+
+    {
+        .name = "across",
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
-        .args = skip_args,
-        .n_args = 1,
-        .infer_schema = infer_schema_passthrough,
-        .create_native = (void *(*)(const cJSON *))tf_skip_create,
+        .memory_class = TF_MEM_ROW_LOCAL,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(batch_rows * selected_columns * functions)",
+        .args = across_args,
+        .n_args = 5,
+        .infer_schema = infer_schema_across,
+        .create_native = (void *(*)(const cJSON *))tf_across_create,
     },
     {
-        .name = "derive",
+        .name = "stats",
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
-        .args = derive_args,
+        .memory_class = TF_MEM_BOUNDED_STATE,
+        .emit_class = TF_EMIT_ON_FLUSH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(columns * requested_stats)",
+        .args = stats_args,
         .n_args = 1,
-        .infer_schema = infer_schema_derive,
-        .create_native = (void *(*)(const cJSON *))tf_derive_create,
+        .infer_schema = infer_schema_stats,
+        .create_native = (void *(*)(const cJSON *))tf_stats_create,
     },
     {
-        .name = "stats",
+        .name = "scan",
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
-        .args = stats_args,
+        .memory_class = TF_MEM_BOUNDED_STATE,
+        .emit_class = TF_EMIT_ON_FLUSH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(columns * profile_stats)",
+        .args = scan_args,
         .n_args = 1,
         .infer_schema = infer_schema_stats,
-        .create_native = (void *(*)(const cJSON *))tf_stats_create,
+        .create_native = (void *(*)(const cJSON *))tf_scan_create,
     },
     {
         .name = "unique",
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_STREAMING | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_KEY_STATE,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_STABLE,
+        .state_estimate = "O(1) sorted, O(distinct_keys) exact unsorted or capped by max_keys/max_state_bytes, O(bloom_bytes) approximate, or O(spill_run_rows * columns) RAM with spill_dir",
         .args = unique_args,
-        .n_args = 1,
+        .n_args = 12,
         .infer_schema = infer_schema_passthrough,
         .create_native = (void *(*)(const cJSON *))tf_unique_create,
     },
@@ -732,8 +2010,12 @@ static tf_op_entry builtin_ops[] = {
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_BLOCKING,
+        .emit_class = TF_EMIT_ON_FLUSH,
+        .schema_class = TF_SCHEMA_STABLE,
+        .state_estimate = "O(input_rows)",
         .args = sort_args,
-        .n_args = 1,
+        .n_args = 5,
         .infer_schema = infer_schema_passthrough,
         .create_native = (void *(*)(const cJSON *))tf_sort_create,
     },
@@ -743,18 +2025,40 @@ static tf_op_entry builtin_ops[] = {
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_ROW_LOCAL,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(batch_rows * selected_columns)",
         .args = select_args,
         .n_args = 1,
         .infer_schema = infer_schema_select,
         .create_native = (void *(*)(const cJSON *))tf_select_create,
     },
+    {
+        .name = "relocate",
+        .kind = TF_OP_TRANSFORM,
+        .tier = TF_TIER_CORE,
+        .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_ROW_LOCAL,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(batch_rows * columns)",
+        .args = relocate_args,
+        .n_args = 3,
+        .infer_schema = infer_schema_relocate,
+        .create_native = (void *(*)(const cJSON *))tf_relocate_create,
+    },
     {
         .name = "dedup",
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_STREAMING | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_KEY_STATE,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_STABLE,
+        .state_estimate = "O(1) sorted, O(distinct_keys) exact unsorted or capped by max_keys/max_state_bytes, O(bloom_bytes) approximate, or O(spill_run_rows * columns) RAM with spill_dir",
         .args = unique_args,
-        .n_args = 1,
+        .n_args = 12,
         .infer_schema = infer_schema_passthrough,
         .create_native = (void *(*)(const cJSON *))tf_unique_create,
     },
@@ -764,16 +2068,94 @@ static tf_op_entry builtin_ops[] = {
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_ROW_LOCAL,
+        .emit_class = TF_EMIT_MIXED,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(batch_rows * columns)",
         .args = validate_args,
-        .n_args = 1,
+        .n_args = 16,
         .infer_schema = infer_schema_validate,
         .create_native = (void *(*)(const cJSON *))tf_validate_create,
     },
+    {
+        .name = "assert",
+        .kind = TF_OP_TRANSFORM,
+        .tier = TF_TIER_CORE,
+        .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_ROW_LOCAL,
+        .emit_class = TF_EMIT_MIXED,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(batch_rows * columns) row mode, O(1) aggregate mode",
+        .args = assert_args,
+        .n_args = 19,
+        .infer_schema = infer_schema_assert,
+        .create_native = (void *(*)(const cJSON *))tf_assert_create,
+    },
+    {
+        .name = "quarantine",
+        .kind = TF_OP_TRANSFORM,
+        .tier = TF_TIER_CORE,
+        .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_ROW_LOCAL,
+        .emit_class = TF_EMIT_MIXED,
+        .schema_class = TF_SCHEMA_STABLE,
+        .state_estimate = "O(batch_rows * columns)",
+        .args = quarantine_args,
+        .n_args = 9,
+        .infer_schema = infer_schema_passthrough,
+        .create_native = (void *(*)(const cJSON *))tf_quarantine_create,
+    },
+    {
+        .name = "tee",
+        .kind = TF_OP_TRANSFORM,
+        .tier = TF_TIER_CORE,
+        .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_ROW_LOCAL,
+        .emit_class = TF_EMIT_MIXED,
+        .schema_class = TF_SCHEMA_STABLE,
+        .state_estimate = "O(batch_rows * selected_columns)",
+        .args = tee_args,
+        .n_args = 13,
+        .infer_schema = infer_schema_passthrough,
+        .create_native = (void *(*)(const cJSON *))tf_tee_create,
+    },
+    {
+        .name = "schema",
+        .kind = TF_OP_TRANSFORM,
+        .tier = TF_TIER_CORE,
+        .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_ROW_LOCAL,
+        .emit_class = TF_EMIT_MIXED,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(batch_rows * declared_columns)",
+        .args = schema_args,
+        .n_args = 13,
+        .infer_schema = infer_schema_schema,
+        .create_native = (void *(*)(const cJSON *))tf_schema_create,
+    },
+    {
+        .name = "schema-infer",
+        .kind = TF_OP_TRANSFORM,
+        .tier = TF_TIER_CORE,
+        .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_BOUNDED_STATE,
+        .emit_class = TF_EMIT_ON_FLUSH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(columns)",
+        .args = schema_infer_args,
+        .n_args = 1,
+        .infer_schema = infer_schema_schema_infer,
+        .create_native = (void *(*)(const cJSON *))tf_schema_infer_create,
+    },
     {
         .name = "trim",
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_ROW_LOCAL,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_STABLE,
+        .state_estimate = "O(batch_rows * columns)",
         .args = trim_args,
         .n_args = 1,
         .infer_schema = infer_schema_passthrough,
@@ -784,8 +2166,12 @@ static tf_op_entry builtin_ops[] = {
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_ROW_LOCAL,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_STABLE,
+        .state_estimate = "O(batch_rows * columns)",
         .args = fill_null_args,
-        .n_args = 1,
+        .n_args = 9,
         .infer_schema = infer_schema_passthrough,
         .create_native = (void *(*)(const cJSON *))tf_fill_null_create,
     },
@@ -794,8 +2180,12 @@ static tf_op_entry builtin_ops[] = {
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_ROW_LOCAL,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(batch_rows * columns)",
         .args = cast_args,
-        .n_args = 1,
+        .n_args = 9,
         .infer_schema = infer_schema_passthrough,  /* type changes at runtime */
         .create_native = (void *(*)(const cJSON *))tf_cast_create,
     },
@@ -804,6 +2194,10 @@ static tf_op_entry builtin_ops[] = {
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_ROW_LOCAL,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_STABLE,
+        .state_estimate = "O(batch_rows)",
         .args = clip_args,
         .n_args = 3,
         .infer_schema = infer_schema_passthrough,
@@ -814,8 +2208,12 @@ static tf_op_entry builtin_ops[] = {
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_ROW_LOCAL,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_STABLE,
+        .state_estimate = "O(batch_rows)",
         .args = replace_args,
-        .n_args = 4,
+        .n_args = 12,
         .infer_schema = infer_schema_passthrough,
         .create_native = (void *(*)(const cJSON *))tf_replace_create,
     },
@@ -824,6 +2222,10 @@ static tf_op_entry builtin_ops[] = {
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_ROW_LOCAL,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(batch_rows * selected_columns)",
         .args = hash_args,
         .n_args = 1,
         .infer_schema = infer_schema_add_hash,
@@ -834,8 +2236,12 @@ static tf_op_entry builtin_ops[] = {
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_ROW_LOCAL,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(boundaries)",
         .args = bin_args,
-        .n_args = 2,
+        .n_args = 4,
         .infer_schema = infer_schema_passthrough,  /* adds column at runtime */
         .create_native = (void *(*)(const cJSON *))tf_bin_create,
     },
@@ -845,6 +2251,10 @@ static tf_op_entry builtin_ops[] = {
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_BOUNDED_STATE,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_STABLE,
+        .state_estimate = "O(columns)",
         .args = fill_down_args,
         .n_args = 1,
         .infer_schema = infer_schema_passthrough,
@@ -855,6 +2265,10 @@ static tf_op_entry builtin_ops[] = {
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_BOUNDED_STATE,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(1)",
         .args = step_args,
         .n_args = 3,
         .infer_schema = infer_schema_passthrough,  /* adds column at runtime */
@@ -865,17 +2279,109 @@ static tf_op_entry builtin_ops[] = {
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_BOUNDED_STATE,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(window_size)",
         .args = window_args,
-        .n_args = 4,
+        .n_args = 6,
         .infer_schema = infer_schema_passthrough,  /* adds column at runtime */
         .create_native = (void *(*)(const cJSON *))tf_window_create,
     },
+    {
+        .name = "rolling-sum",
+        .kind = TF_OP_TRANSFORM,
+        .tier = TF_TIER_CORE,
+        .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_BOUNDED_STATE,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(window_size)",
+        .args = rolling_args,
+        .n_args = 5,
+        .infer_schema = infer_schema_passthrough,
+        .create_native = (void *(*)(const cJSON *))tf_rolling_sum_create,
+    },
+    {
+        .name = "rolling-mean",
+        .kind = TF_OP_TRANSFORM,
+        .tier = TF_TIER_CORE,
+        .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_BOUNDED_STATE,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(window_size)",
+        .args = rolling_args,
+        .n_args = 5,
+        .infer_schema = infer_schema_passthrough,
+        .create_native = (void *(*)(const cJSON *))tf_rolling_mean_create,
+    },
+    {
+        .name = "rolling-min",
+        .kind = TF_OP_TRANSFORM,
+        .tier = TF_TIER_CORE,
+        .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_BOUNDED_STATE,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(window_size)",
+        .args = rolling_args,
+        .n_args = 5,
+        .infer_schema = infer_schema_passthrough,
+        .create_native = (void *(*)(const cJSON *))tf_rolling_min_create,
+    },
+    {
+        .name = "rolling-max",
+        .kind = TF_OP_TRANSFORM,
+        .tier = TF_TIER_CORE,
+        .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_BOUNDED_STATE,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(window_size)",
+        .args = rolling_args,
+        .n_args = 5,
+        .infer_schema = infer_schema_passthrough,
+        .create_native = (void *(*)(const cJSON *))tf_rolling_max_create,
+    },
+    {
+        .name = "rolling-any",
+        .kind = TF_OP_TRANSFORM,
+        .tier = TF_TIER_CORE,
+        .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_BOUNDED_STATE,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(window_size)",
+        .args = rolling_bool_args,
+        .n_args = 4,
+        .infer_schema = infer_schema_passthrough,
+        .create_native = (void *(*)(const cJSON *))tf_rolling_any_create,
+    },
+    {
+        .name = "rolling-all",
+        .kind = TF_OP_TRANSFORM,
+        .tier = TF_TIER_CORE,
+        .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_BOUNDED_STATE,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(window_size)",
+        .args = rolling_bool_args,
+        .n_args = 4,
+        .infer_schema = infer_schema_passthrough,
+        .create_native = (void *(*)(const cJSON *))tf_rolling_all_create,
+    },
     /* ---- Row-multiplying streaming ---- */
     {
         .name = "explode",
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_STREAMING | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_ROW_LOCAL,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_STABLE,
+        .state_estimate = "O(batch_rows)",
         .args = explode_args,
         .n_args = 2,
         .infer_schema = infer_schema_passthrough,
@@ -886,6 +2392,10 @@ static tf_op_entry builtin_ops[] = {
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_ROW_LOCAL,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(batch_rows * output_columns)",
         .args = split_args,
         .n_args = 3,
         .infer_schema = infer_schema_passthrough,  /* adds columns at runtime */
@@ -896,6 +2406,10 @@ static tf_op_entry builtin_ops[] = {
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_STREAMING | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_ROW_LOCAL,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(batch_rows * unpivot_columns)",
         .args = unpivot_args,
         .n_args = 1,
         .infer_schema = infer_schema_passthrough,  /* schema changes at runtime */
@@ -907,6 +2421,24 @@ static tf_op_entry builtin_ops[] = {
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_BOUNDED_STATE,
+        .emit_class = TF_EMIT_ON_FLUSH,
+        .schema_class = TF_SCHEMA_STABLE,
+        .state_estimate = "O(n)",
+        .args = tail_args,
+        .n_args = 1,
+        .infer_schema = infer_schema_passthrough,
+        .create_native = (void *(*)(const cJSON *))tf_tail_create,
+    },
+    {
+        .name = "slice-tail",
+        .kind = TF_OP_TRANSFORM,
+        .tier = TF_TIER_CORE,
+        .caps = TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_BOUNDED_STATE,
+        .emit_class = TF_EMIT_ON_FLUSH,
+        .schema_class = TF_SCHEMA_STABLE,
+        .state_estimate = "O(n)",
         .args = tail_args,
         .n_args = 1,
         .infer_schema = infer_schema_passthrough,
@@ -917,18 +2449,82 @@ static tf_op_entry builtin_ops[] = {
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_BOUNDED_STATE,
+        .emit_class = TF_EMIT_ON_FLUSH,
+        .schema_class = TF_SCHEMA_STABLE,
+        .state_estimate = "O(n)",
         .args = top_args,
         .n_args = 3,
         .infer_schema = infer_schema_passthrough,
         .create_native = (void *(*)(const cJSON *))tf_top_create,
     },
+    {
+        .name = "top-k",
+        .kind = TF_OP_TRANSFORM,
+        .tier = TF_TIER_CORE,
+        .caps = TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_BOUNDED_STATE,
+        .emit_class = TF_EMIT_ON_FLUSH,
+        .schema_class = TF_SCHEMA_STABLE,
+        .state_estimate = "O(n)",
+        .args = top_args,
+        .n_args = 3,
+        .infer_schema = infer_schema_passthrough,
+        .create_native = (void *(*)(const cJSON *))tf_top_k_create,
+    },
+    {
+        .name = "bottom-k",
+        .kind = TF_OP_TRANSFORM,
+        .tier = TF_TIER_CORE,
+        .caps = TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_BOUNDED_STATE,
+        .emit_class = TF_EMIT_ON_FLUSH,
+        .schema_class = TF_SCHEMA_STABLE,
+        .state_estimate = "O(n)",
+        .args = top_args,
+        .n_args = 3,
+        .infer_schema = infer_schema_passthrough,
+        .create_native = (void *(*)(const cJSON *))tf_bottom_k_create,
+    },
+    {
+        .name = "slice-min",
+        .kind = TF_OP_TRANSFORM,
+        .tier = TF_TIER_CORE,
+        .caps = TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_BOUNDED_STATE,
+        .emit_class = TF_EMIT_ON_FLUSH,
+        .schema_class = TF_SCHEMA_STABLE,
+        .state_estimate = "O(n)",
+        .args = top_args,
+        .n_args = 4,
+        .infer_schema = infer_schema_passthrough,
+        .create_native = (void *(*)(const cJSON *))tf_slice_min_create,
+    },
+    {
+        .name = "slice-max",
+        .kind = TF_OP_TRANSFORM,
+        .tier = TF_TIER_CORE,
+        .caps = TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_BOUNDED_STATE,
+        .emit_class = TF_EMIT_ON_FLUSH,
+        .schema_class = TF_SCHEMA_STABLE,
+        .state_estimate = "O(n)",
+        .args = top_args,
+        .n_args = 4,
+        .infer_schema = infer_schema_passthrough,
+        .create_native = (void *(*)(const cJSON *))tf_slice_max_create,
+    },
     {
         .name = "sample",
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE,
+        .memory_class = TF_MEM_BOUNDED_STATE,
+        .emit_class = TF_EMIT_ON_FLUSH,
+        .schema_class = TF_SCHEMA_STABLE,
+        .state_estimate = "O(n)",
         .args = sample_args,
-        .n_args = 1,
+        .n_args = 2,
         .infer_schema = infer_schema_passthrough,
         .create_native = (void *(*)(const cJSON *))tf_sample_create,
     },
@@ -937,8 +2533,12 @@ static tf_op_entry builtin_ops[] = {
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_KEY_STATE,
+        .emit_class = TF_EMIT_MIXED,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(1) sorted, O(distinct_groups) unsorted or capped by max_groups/max_state_bytes, or O(spill_run_rows * columns) RAM with spill_dir",
         .args = group_agg_args,
-        .n_args = 2,
+        .n_args = 9,
         .infer_schema = infer_schema_group_agg,
         .create_native = (void *(*)(const cJSON *))tf_group_agg_create,
     },
@@ -947,8 +2547,12 @@ static tf_op_entry builtin_ops[] = {
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_KEY_STATE,
+        .emit_class = TF_EMIT_ON_FLUSH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(distinct_values) or capped by max_values/max_state_bytes",
         .args = frequency_args,
-        .n_args = 1,
+        .n_args = 13,
         .infer_schema = infer_schema_frequency,
         .create_native = (void *(*)(const cJSON *))tf_frequency_create,
     },
@@ -958,16 +2562,80 @@ static tf_op_entry builtin_ops[] = {
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_ROW_LOCAL,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(batch_rows)",
         .args = datetime_args,
-        .n_args = 2,
+        .n_args = 4,
         .infer_schema = infer_schema_passthrough,  /* adds columns at runtime */
         .create_native = (void *(*)(const cJSON *))tf_datetime_create,
     },
+    {
+        .name = "json-extract",
+        .kind = TF_OP_TRANSFORM,
+        .tier = TF_TIER_CORE,
+        .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_ROW_LOCAL,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(batch_rows + path_segments)",
+        .args = json_extract_args,
+        .n_args = 4,
+        .infer_schema = infer_schema_json_extract,
+        .create_native = (void *(*)(const cJSON *))tf_json_extract_create,
+    },
+    {
+        .name = "json-filter",
+        .kind = TF_OP_TRANSFORM,
+        .tier = TF_TIER_CORE,
+        .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_ROW_LOCAL,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_STABLE,
+        .state_estimate = "O(batch_rows + path_segments)",
+        .args = json_filter_args,
+        .n_args = 5,
+        .infer_schema = infer_schema_passthrough,
+        .create_native = (void *(*)(const cJSON *))tf_json_filter_create,
+    },
+    {
+        .name = "json-schema",
+        .kind = TF_OP_TRANSFORM,
+        .tier = TF_TIER_CORE,
+        .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_ROW_LOCAL,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(batch_rows + schema_nodes)",
+        .args = json_schema_args,
+        .n_args = 12,
+        .infer_schema = infer_schema_json_schema,
+        .create_native = (void *(*)(const cJSON *))tf_json_schema_create,
+    },
+    {
+        .name = "json-flatten",
+        .kind = TF_OP_TRANSFORM,
+        .tier = TF_TIER_CORE,
+        .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_ROW_LOCAL,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(batch_rows * fields + path_segments)",
+        .args = json_flatten_args,
+        .n_args = 2,
+        .infer_schema = infer_schema_json_flatten,
+        .create_native = (void *(*)(const cJSON *))tf_json_flatten_create,
+    },
     {
         .name = "flatten",
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_ROW_LOCAL,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(batch_rows * fields)",
         .args = NULL,
         .n_args = 0,
         .infer_schema = infer_schema_passthrough,
@@ -979,9 +2647,13 @@ static tf_op_entry builtin_ops[] = {
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_BLOCKING,
+        .emit_class = TF_EMIT_ON_FLUSH,
+        .schema_class = TF_SCHEMA_DATA_DEPENDENT,
+        .state_estimate = "O(input_rows + distinct_categories), O(current_group + categories) with categories+sorted=true, or external spill with categories/max_categories",
         .args = pivot_args,
-        .n_args = 3,
-        .infer_schema = infer_schema_passthrough,  /* schema changes at runtime */
+        .n_args = 10,
+        .infer_schema = infer_schema_pivot,
         .create_native = (void *(*)(const cJSON *))tf_pivot_create,
     },
     {
@@ -989,16 +2661,136 @@ static tf_op_entry builtin_ops[] = {
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_STREAMING | TF_CAP_FS | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_KEY_STATE,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_DATA_DEPENDENT,
+        .state_estimate = "O(current_lookup_run) sorted, O(lookup_rows + lookup_keys + output_batch) unsorted or capped by max_lookup_*/max_state_bytes/max_output_rows, or O(spill_run_rows * columns + max_matches_per_row) RAM with spill_dir",
         .args = join_args,
-        .n_args = 3,
+        .n_args = 14,
         .infer_schema = infer_schema_passthrough,  /* schema depends on lookup file */
         .create_native = (void *(*)(const cJSON *))tf_join_create,
     },
+    {
+        .name = "semi-join",
+        .kind = TF_OP_TRANSFORM,
+        .tier = TF_TIER_CORE,
+        .caps = TF_CAP_STREAMING | TF_CAP_FS | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_KEY_STATE,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_STABLE,
+        .state_estimate = "O(1) sorted, O(lookup_keys) unsorted or capped by max_lookup_*/max_state_bytes/max_output_rows, or O(spill_run_rows * columns) RAM with spill_dir",
+        .args = join_args,
+        .n_args = 14,
+        .infer_schema = infer_schema_passthrough,
+        .create_native = (void *(*)(const cJSON *))tf_semi_join_create,
+    },
+    {
+        .name = "anti-join",
+        .kind = TF_OP_TRANSFORM,
+        .tier = TF_TIER_CORE,
+        .caps = TF_CAP_STREAMING | TF_CAP_FS | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_KEY_STATE,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_STABLE,
+        .state_estimate = "O(1) sorted, O(lookup_keys) unsorted or capped by max_lookup_*/max_state_bytes/max_output_rows, or O(spill_run_rows * columns) RAM with spill_dir",
+        .args = join_args,
+        .n_args = 14,
+        .infer_schema = infer_schema_passthrough,
+        .create_native = (void *(*)(const cJSON *))tf_anti_join_create,
+    },
+    {
+        .name = "intersect",
+        .kind = TF_OP_TRANSFORM,
+        .tier = TF_TIER_CORE,
+        .caps = TF_CAP_STREAMING | TF_CAP_FS | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_KEY_STATE,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_STABLE,
+        .state_estimate = "O(1) sorted, O(lookup_keys + emitted_keys) unsorted or capped by max_lookup_*/max_output_keys/max_state_bytes",
+        .args = set_file_args,
+        .n_args = 12,
+        .infer_schema = infer_schema_passthrough,
+        .create_native = (void *(*)(const cJSON *))tf_intersect_create,
+    },
+    {
+        .name = "setdiff",
+        .kind = TF_OP_TRANSFORM,
+        .tier = TF_TIER_CORE,
+        .caps = TF_CAP_STREAMING | TF_CAP_FS | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_KEY_STATE,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_STABLE,
+        .state_estimate = "O(1) sorted, O(lookup_keys + emitted_keys) unsorted or capped by max_lookup_*/max_output_keys/max_state_bytes",
+        .args = set_file_args,
+        .n_args = 12,
+        .infer_schema = infer_schema_passthrough,
+        .create_native = (void *(*)(const cJSON *))tf_setdiff_create,
+    },
+    {
+        .name = "intersect-all",
+        .kind = TF_OP_TRANSFORM,
+        .tier = TF_TIER_CORE,
+        .caps = TF_CAP_STREAMING | TF_CAP_FS | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_KEY_STATE,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_STABLE,
+        .state_estimate = "O(lookup_keys) unsorted with max_lookup_keys/max_state_bytes; O(spill_run_rows * columns) RAM with spill_dir; O(1) current-run state with sorted=true; emits min(left_count, lookup_count) rows per key",
+        .args = set_file_args,
+        .n_args = 12,
+        .infer_schema = infer_schema_passthrough,
+        .create_native = (void *(*)(const cJSON *))tf_intersect_all_create,
+    },
+    {
+        .name = "setdiff-all",
+        .kind = TF_OP_TRANSFORM,
+        .tier = TF_TIER_CORE,
+        .caps = TF_CAP_STREAMING | TF_CAP_FS | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_KEY_STATE,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_STABLE,
+        .state_estimate = "O(lookup_keys) unsorted with max_lookup_keys/max_state_bytes; O(spill_run_rows * columns) RAM with spill_dir; O(1) current-run state with sorted=true; emits max(left_count - lookup_count, 0) rows per key",
+        .args = set_file_args,
+        .n_args = 12,
+        .infer_schema = infer_schema_passthrough,
+        .create_native = (void *(*)(const cJSON *))tf_setdiff_all_create,
+    },
+    {
+        .name = "union",
+        .kind = TF_OP_TRANSFORM,
+        .tier = TF_TIER_CORE,
+        .caps = TF_CAP_STREAMING | TF_CAP_FS | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_KEY_STATE,
+        .emit_class = TF_EMIT_MIXED,
+        .schema_class = TF_SCHEMA_STABLE,
+        .state_estimate = "O(emitted_keys), capped by max_output_keys/max_state_bytes; O(previous_left_key + current_file_key) with sorted=true; O(spill_run_rows * columns) RAM with spill_dir",
+        .args = union_args,
+        .n_args = 11,
+        .infer_schema = infer_schema_passthrough,
+        .create_native = (void *(*)(const cJSON *))tf_union_create,
+    },
+    {
+        .name = "union-all",
+        .kind = TF_OP_TRANSFORM,
+        .tier = TF_TIER_CORE,
+        .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_FS | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_BOUNDED_STATE,
+        .emit_class = TF_EMIT_MIXED,
+        .schema_class = TF_SCHEMA_STABLE,
+        .state_estimate = "O(batch_rows)",
+        .args = union_all_args,
+        .n_args = 3,
+        .infer_schema = infer_schema_passthrough,
+        .create_native = (void *(*)(const cJSON *))tf_union_all_create,
+    },
     {
         .name = "stack",
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
-        .caps = TF_CAP_FS | TF_CAP_DETERMINISTIC,
+        .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_FS | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_BOUNDED_STATE,
+        .emit_class = TF_EMIT_MIXED,
+        .schema_class = TF_SCHEMA_STABLE,
+        .state_estimate = "O(batch_rows)",
         .args = stack_args,
         .n_args = 3,
         .infer_schema = infer_schema_passthrough,
@@ -1009,18 +2801,82 @@ static tf_op_entry builtin_ops[] = {
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_BOUNDED_STATE,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(offset)",
         .args = lead_args,
         .n_args = 3,
-        .infer_schema = infer_schema_passthrough,
+        .infer_schema = infer_schema_lead,
         .create_native = (void *(*)(const cJSON *))tf_lead_create,
     },
+    {
+        .name = "lag",
+        .kind = TF_OP_TRANSFORM,
+        .tier = TF_TIER_CORE,
+        .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_BOUNDED_STATE,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(offset * row_width)",
+        .args = lag_args,
+        .n_args = 3,
+        .infer_schema = infer_schema_lag,
+        .create_native = (void *(*)(const cJSON *))tf_lag_create,
+    },
+    {
+        .name = "shift",
+        .kind = TF_OP_TRANSFORM,
+        .tier = TF_TIER_CORE,
+        .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_BOUNDED_STATE,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(offset * row_width)",
+        .args = shift_args,
+        .n_args = 4,
+        .infer_schema = infer_schema_shift,
+        .create_native = (void *(*)(const cJSON *))tf_shift_create,
+    },
+    {
+        .name = "rowid",
+        .kind = TF_OP_TRANSFORM,
+        .tier = TF_TIER_CORE,
+        .caps = TF_CAP_STREAMING | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_KEY_STATE,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(1) global/sorted, O(distinct_keys) unsorted or capped by max_keys/max_state_bytes",
+        .args = rowid_args,
+        .n_args = 5,
+        .infer_schema = infer_schema_rowid,
+        .create_native = (void *(*)(const cJSON *))tf_rowid_create,
+    },
+    {
+        .name = "rleid",
+        .kind = TF_OP_TRANSFORM,
+        .tier = TF_TIER_CORE,
+        .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_BOUNDED_STATE,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(key_width)",
+        .args = rleid_args,
+        .n_args = 2,
+        .infer_schema = infer_schema_rleid,
+        .create_native = (void *(*)(const cJSON *))tf_rleid_create,
+    },
     {
         .name = "date-trunc",
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_ROW_LOCAL,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(batch_rows)",
         .args = date_trunc_args,
-        .n_args = 3,
+        .n_args = 5,
         .infer_schema = infer_schema_passthrough,
         .create_native = (void *(*)(const cJSON *))tf_date_trunc_create,
     },
@@ -1029,8 +2885,12 @@ static tf_op_entry builtin_ops[] = {
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_STREAMING | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_KEY_STATE,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_DATA_DEPENDENT,
+        .state_estimate = "O(distinct_categories) or capped by max_categories/max_state_bytes",
         .args = onehot_args,
-        .n_args = 2,
+        .n_args = 6,
         .infer_schema = infer_schema_passthrough,
         .create_native = (void *(*)(const cJSON *))tf_onehot_create,
     },
@@ -1039,8 +2899,12 @@ static tf_op_entry builtin_ops[] = {
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_STREAMING | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_KEY_STATE,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(distinct_categories) or capped by max_categories/max_state_bytes",
         .args = label_encode_args,
-        .n_args = 2,
+        .n_args = 6,
         .infer_schema = infer_schema_passthrough,
         .create_native = (void *(*)(const cJSON *))tf_label_encode_create,
     },
@@ -1049,8 +2913,12 @@ static tf_op_entry builtin_ops[] = {
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_BOUNDED_STATE,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(1)",
         .args = ewma_args,
-        .n_args = 3,
+        .n_args = 5,
         .infer_schema = infer_schema_passthrough,
         .create_native = (void *(*)(const cJSON *))tf_ewma_create,
     },
@@ -1059,6 +2927,10 @@ static tf_op_entry builtin_ops[] = {
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_BOUNDED_STATE,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(order)",
         .args = diff_args,
         .n_args = 3,
         .infer_schema = infer_schema_passthrough,
@@ -1069,8 +2941,12 @@ static tf_op_entry builtin_ops[] = {
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_BOUNDED_STATE,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(1)",
         .args = anomaly_args,
-        .n_args = 3,
+        .n_args = 5,
         .infer_schema = infer_schema_passthrough,
         .create_native = (void *(*)(const cJSON *))tf_anomaly_create,
     },
@@ -1079,6 +2955,10 @@ static tf_op_entry builtin_ops[] = {
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_STREAMING | TF_CAP_BOUNDED_MEMORY | TF_CAP_BROWSER_SAFE,
+        .memory_class = TF_MEM_BOUNDED_STATE,
+        .emit_class = TF_EMIT_PER_BATCH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(1)",
         .args = split_data_args,
         .n_args = 3,
         .infer_schema = infer_schema_passthrough,
@@ -1089,8 +2969,12 @@ static tf_op_entry builtin_ops[] = {
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_BLOCKING,
+        .emit_class = TF_EMIT_ON_FLUSH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(input_rows)",
         .args = interpolate_args,
-        .n_args = 2,
+        .n_args = 4,
         .infer_schema = infer_schema_passthrough,
         .create_native = (void *(*)(const cJSON *))tf_interpolate_create,
     },
@@ -1099,8 +2983,12 @@ static tf_op_entry builtin_ops[] = {
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_BLOCKING,
+        .emit_class = TF_EMIT_ON_FLUSH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(input_rows)",
         .args = normalize_args,
-        .n_args = 2,
+        .n_args = 12,
         .infer_schema = infer_schema_passthrough,
         .create_native = (void *(*)(const cJSON *))tf_normalize_create,
     },
@@ -1109,8 +2997,12 @@ static tf_op_entry builtin_ops[] = {
         .kind = TF_OP_TRANSFORM,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_BLOCKING,
+        .emit_class = TF_EMIT_ON_FLUSH,
+        .schema_class = TF_SCHEMA_PARAMETRIC,
+        .state_estimate = "O(input_rows)",
         .args = acf_args,
-        .n_args = 2,
+        .n_args = 4,
         .infer_schema = infer_schema_passthrough,
         .create_native = (void *(*)(const cJSON *))tf_acf_create,
     },
@@ -1119,6 +3011,10 @@ static tf_op_entry builtin_ops[] = {
         .kind = TF_OP_ENCODER,
         .tier = TF_TIER_CORE,
         .caps = TF_CAP_BROWSER_SAFE | TF_CAP_DETERMINISTIC,
+        .memory_class = TF_MEM_BLOCKING,
+        .emit_class = TF_EMIT_ON_FLUSH,
+        .schema_class = TF_SCHEMA_STABLE,
+        .state_estimate = "O(input_rows)",
         .args = table_encode_args,
         .n_args = 2,
         .infer_schema = infer_schema_sink,