tranfi 0.1.2 → 0.2.0

package/csrc/op_diff.c

@@ -12,18 +12,93 @@
 
 #define MAX_DIFF_ORDER 8
 
+typedef enum {
+    DIFF_MISSING_ERROR,
+    DIFF_MISSING_NULL,
+    DIFF_MISSING_IGNORE,
+} diff_missing_policy;
+
+typedef enum {
+    DIFF_TYPE_FAIL,
+    DIFF_TYPE_NULL,
+} diff_type_policy;
+
 typedef struct {
     char   *column;
     char   *result;
     int     order;
     double  prev[MAX_DIFF_ORDER]; /* circular buffer of previous values */
     int     count; /* rows seen so far */
+    diff_missing_policy missing;
+    diff_type_policy on_type_error;
 } diff_state;
 
+static int diff_is_numeric_type(tf_type type) {
+    return type == TF_TYPE_INT64 || type == TF_TYPE_FLOAT64;
+}
+
 static double get_numeric(const tf_batch *b, size_t r, int ci) {
     if (b->col_types[ci] == TF_TYPE_INT64) return (double)tf_batch_get_int64(b, r, ci);
-    if (b->col_types[ci] == TF_TYPE_FLOAT64) return tf_batch_get_float64(b, r, ci);
-    return 0;
+    return tf_batch_get_float64(b, r, ci);
+}
+
+static void diff_set_col_error(const char *column, const char *suffix) {
+    char msg[512];
+    snprintf(msg, sizeof(msg), "diff: column '%s' %s", column ? column : "", suffix);
+    tf_set_last_error(msg);
+}
+
+static int diff_parse_missing_policy(const cJSON *args, diff_missing_policy *out) {
+    *out = DIFF_MISSING_ERROR;
+    const cJSON *j = cJSON_GetObjectItemCaseSensitive(args, "missing");
+    if (!j) return TF_OK;
+    if (!cJSON_IsString(j)) {
+        tf_set_last_error("diff: missing must be error, null, or ignore");
+        return TF_ERROR;
+    }
+    if (strcmp(j->valuestring, "error") == 0) *out = DIFF_MISSING_ERROR;
+    else if (strcmp(j->valuestring, "null") == 0) *out = DIFF_MISSING_NULL;
+    else if (strcmp(j->valuestring, "ignore") == 0) *out = DIFF_MISSING_IGNORE;
+    else {
+        tf_set_last_error("diff: missing must be error, null, or ignore");
+        return TF_ERROR;
+    }
+    return TF_OK;
+}
+
+static int diff_parse_type_policy(const cJSON *args, diff_type_policy *out) {
+    *out = DIFF_TYPE_FAIL;
+    const cJSON *j = cJSON_GetObjectItemCaseSensitive(args, "on_type_error");
+    if (!j) return TF_OK;
+    if (!cJSON_IsString(j)) {
+        tf_set_last_error("diff: on_type_error must be fail or null");
+        return TF_ERROR;
+    }
+    if (strcmp(j->valuestring, "fail") == 0) *out = DIFF_TYPE_FAIL;
+    else if (strcmp(j->valuestring, "null") == 0) *out = DIFF_TYPE_NULL;
+    else {
+        tf_set_last_error("diff: on_type_error must be fail or null");
+        return TF_ERROR;
+    }
+    return TF_OK;
+}
+
+static int diff_passthrough(tf_batch *in, tf_batch **out) {
+    tf_batch *ob = tf_batch_create(in->n_cols, in->n_rows);
+    if (!ob) return TF_ERROR;
+    if (tf_batch_clone_schema(ob, in) != TF_OK) {
+        tf_batch_free(ob);
+        return TF_ERROR;
+    }
+    for (size_t r = 0; r < in->n_rows; r++) {
+        if (tf_batch_copy_row(ob, r, in, r) != TF_OK ||
+            tf_batch_expose_row(ob, r) != TF_OK) {
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
+    }
+    *out = ob;
+    return TF_OK;
 }
 
 static int diff_process(tf_step *self, tf_batch *in, tf_batch **out,
@@ -32,31 +107,57 @@ static int diff_process(tf_step *self, tf_batch *in, tf_batch **out,
     diff_state *st = self->state;
     *out = NULL;
 
+    int ci = tf_batch_col_index(in, st->column);
+    int force_null = 0;
+    if (ci < 0) {
+        if (st->missing == DIFF_MISSING_ERROR) {
+            diff_set_col_error(st->column, "not found");
+            return TF_ERROR;
+        }
+        if (st->missing == DIFF_MISSING_IGNORE) {
+            return diff_passthrough(in, out);
+        }
+        force_null = 1;
+    } else if (!diff_is_numeric_type(in->col_types[(size_t)ci])) {
+        if (st->on_type_error == DIFF_TYPE_FAIL) {
+            diff_set_col_error(st->column, "must be numeric");
+            return TF_ERROR;
+        }
+        force_null = 1;
+    }
+
+    const char *extra_names[1] = {st->result};
+    tf_type extra_types[1] = {TF_TYPE_FLOAT64};
     tf_batch *ob = tf_batch_create(in->n_cols + 1, in->n_rows);
     if (!ob) return TF_ERROR;
-    for (size_t c = 0; c < in->n_cols; c++)
-        tf_batch_set_schema(ob, c, in->col_names[c], in->col_types[c]);
-    tf_batch_set_schema(ob, in->n_cols, st->result, TF_TYPE_FLOAT64);
-
-    int ci = tf_batch_col_index(in, st->column);
+    if (tf_batch_clone_with_extra_cols(ob, in, extra_names, extra_types, 1) != TF_OK) {
+        tf_batch_free(ob);
+        return TF_ERROR;
+    }
 
     for (size_t r = 0; r < in->n_rows; r++) {
-        tf_batch_copy_row(ob, r, in, r);
+        if (tf_batch_copy_row(ob, r, in, r) != TF_OK) {
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
 
-        if (ci < 0 || tf_batch_is_null(in, r, ci)) {
-            tf_batch_set_null(ob, r, in->n_cols);
-            ob->n_rows = r + 1;
+        if (force_null || tf_batch_is_null(in, r, (size_t)ci)) {
+            if (tf_batch_set_null(ob, r, in->n_cols) != TF_OK) { tf_batch_free(ob); return TF_ERROR; }
+            if (tf_batch_expose_row(ob, r) != TF_OK) { tf_batch_free(ob); return TF_ERROR; }
             continue;
         }
 
         double val = get_numeric(in, r, ci);
 
         if (st->count < st->order) {
-            /* Not enough history yet */
-            st->prev[st->count] = val;
+            /* Not enough history yet -- shift and insert at front
+             * so prev[0] is always the most recent value */
+            if (tf_batch_set_null(ob, r, in->n_cols) != TF_OK) { tf_batch_free(ob); return TF_ERROR; }
+            if (tf_batch_expose_row(ob, r) != TF_OK) { tf_batch_free(ob); return TF_ERROR; }
+            for (int k = st->count; k > 0; k--)
+                st->prev[k] = st->prev[k - 1];
+            st->prev[0] = val;
             st->count++;
-            tf_batch_set_null(ob, r, in->n_cols);
-            ob->n_rows = r + 1;
             continue;
         }
 
@@ -78,8 +179,14 @@ static int diff_process(tf_step *self, tf_batch *in, tf_batch **out,
             result += sign * binom * st->prev[k - 1];
         }
 
-        tf_batch_set_float64(ob, r, in->n_cols, result);
-        ob->n_rows = r + 1;
+        if (tf_batch_set_float64(ob, r, in->n_cols, result) != TF_OK) {
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
+        if (tf_batch_expose_row(ob, r) != TF_OK) {
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
 
         /* Shift prev buffer: move everything down, put val at [0] */
         for (int k = st->order - 1; k > 0; k--)
@@ -104,27 +211,36 @@ static void diff_destroy(tf_step *self) {
 tf_step *tf_diff_create(const cJSON *args) {
     if (!args) return NULL;
     cJSON *col_j = cJSON_GetObjectItemCaseSensitive(args, "column");
-    if (!cJSON_IsString(col_j)) return NULL;
+    if (!cJSON_IsString(col_j) || !col_j->valuestring[0]) {
+        tf_set_last_error("diff: column is required");
+        return NULL;
+    }
 
-    diff_state *st = calloc(1, sizeof(diff_state));
+    diff_state *st = tf_callocarray_checked(1, sizeof(diff_state));
     if (!st) return NULL;
-    st->column = strdup(col_j->valuestring);
-
-    cJSON *order_j = cJSON_GetObjectItemCaseSensitive(args, "order");
-    st->order = (cJSON_IsNumber(order_j) && order_j->valueint > 0) ?
-                order_j->valueint : 1;
-    if (st->order > MAX_DIFF_ORDER) st->order = MAX_DIFF_ORDER;
+    st->column = tf_strdup_checked(col_j->valuestring);
+    if (!st->column) { free(st); return NULL; }
+
+    size_t order = 1;
+    int has_order = tf_json_get_size_arg(args, "order", 1, MAX_DIFF_ORDER, &order, "diff");
+    if (has_order < 0) { free(st->column); free(st); return NULL; }
+    st->order = (int)order;
+    if (diff_parse_missing_policy(args, &st->missing) != TF_OK ||
+        diff_parse_type_policy(args, &st->on_type_error) != TF_OK) {
+        free(st->column);
+        free(st);
+        return NULL;
+    }
 
     cJSON *res_j = cJSON_GetObjectItemCaseSensitive(args, "result");
     if (cJSON_IsString(res_j)) {
-        st->result = strdup(res_j->valuestring);
+        st->result = tf_strdup_checked(res_j->valuestring);
     } else {
-        char buf[256];
-        snprintf(buf, sizeof(buf), "%s_diff", st->column);
-        st->result = strdup(buf);
+        st->result = tf_string_append_suffix_checked(st->column, "_diff");
     }
+    if (!st->result) { free(st->column); free(st); return NULL; }
 
-    tf_step *step = malloc(sizeof(tf_step));
+    tf_step *step = tf_callocarray_checked(1, sizeof(tf_step));
     if (!step) { free(st->column); free(st->result); free(st); return NULL; }
     step->process = diff_process;
     step->flush = diff_flush;

package/csrc/op_ewma.c

@@ -9,6 +9,18 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
+#include <math.h>
+
+typedef enum {
+    EWMA_MISSING_ERROR,
+    EWMA_MISSING_NULL,
+    EWMA_MISSING_IGNORE,
+} ewma_missing_policy;
+
+typedef enum {
+    EWMA_TYPE_FAIL,
+    EWMA_TYPE_NULL,
+} ewma_type_policy;
 
 typedef struct {
     char   *column;
@@ -16,12 +28,79 @@ typedef struct {
     double  alpha;
     double  ewma;
     int     initialized;
+    ewma_missing_policy missing;
+    ewma_type_policy on_type_error;
 } ewma_state;
 
-static double get_numeric(const tf_batch *b, size_t r, int ci) {
+static int ewma_is_numeric_type(tf_type type) {
+    return type == TF_TYPE_INT64 || type == TF_TYPE_FLOAT64;
+}
+
+static double ewma_get_numeric(const tf_batch *b, size_t r, int ci) {
     if (b->col_types[ci] == TF_TYPE_INT64) return (double)tf_batch_get_int64(b, r, ci);
-    if (b->col_types[ci] == TF_TYPE_FLOAT64) return tf_batch_get_float64(b, r, ci);
-    return 0;
+    return tf_batch_get_float64(b, r, ci);
+}
+
+static void ewma_set_col_error(const char *column, const char *suffix) {
+    char msg[512];
+    snprintf(msg, sizeof(msg), "ewma: column '%s' %s", column ? column : "", suffix);
+    tf_set_last_error(msg);
+}
+
+static int ewma_parse_missing_policy(const cJSON *args, ewma_missing_policy *out) {
+    *out = EWMA_MISSING_ERROR;
+    const cJSON *j = cJSON_GetObjectItemCaseSensitive(args, "missing");
+    if (!j) return TF_OK;
+    if (!cJSON_IsString(j)) {
+        tf_set_last_error("ewma: missing must be error, null, or ignore");
+        return TF_ERROR;
+    }
+    if (strcmp(j->valuestring, "error") == 0) *out = EWMA_MISSING_ERROR;
+    else if (strcmp(j->valuestring, "null") == 0) *out = EWMA_MISSING_NULL;
+    else if (strcmp(j->valuestring, "ignore") == 0) *out = EWMA_MISSING_IGNORE;
+    else {
+        tf_set_last_error("ewma: missing must be error, null, or ignore");
+        return TF_ERROR;
+    }
+    return TF_OK;
+}
+
+static int ewma_parse_type_policy(const cJSON *args, ewma_type_policy *out) {
+    *out = EWMA_TYPE_FAIL;
+    const cJSON *j = cJSON_GetObjectItemCaseSensitive(args, "on_type_error");
+    if (!j) return TF_OK;
+    if (!cJSON_IsString(j)) {
+        tf_set_last_error("ewma: on_type_error must be fail or null");
+        return TF_ERROR;
+    }
+    if (strcmp(j->valuestring, "fail") == 0) *out = EWMA_TYPE_FAIL;
+    else if (strcmp(j->valuestring, "null") == 0) *out = EWMA_TYPE_NULL;
+    else {
+        tf_set_last_error("ewma: on_type_error must be fail or null");
+        return TF_ERROR;
+    }
+    return TF_OK;
+}
+
+static int ewma_passthrough(tf_batch *in, tf_batch **out) {
+    tf_batch *ob = tf_batch_create(in->n_cols, in->n_rows);
+    if (!ob) return TF_ERROR;
+    if (tf_batch_clone_schema(ob, in) != TF_OK) {
+        tf_batch_free(ob);
+        return TF_ERROR;
+    }
+    for (size_t r = 0; r < in->n_rows; r++) {
+        if (tf_batch_copy_row(ob, r, in, r) != TF_OK) {
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
+        if (tf_batch_expose_row(ob, r) != TF_OK) {
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
+    }
+    *out = ob;
+    return TF_OK;
 }
 
 static int ewma_process(tf_step *self, tf_batch *in, tf_batch **out,
@@ -30,33 +109,59 @@ static int ewma_process(tf_step *self, tf_batch *in, tf_batch **out,
     ewma_state *st = self->state;
     *out = NULL;
 
+    int ci = tf_batch_col_index(in, st->column);
+    int force_null = 0;
+    if (ci < 0) {
+        if (st->missing == EWMA_MISSING_ERROR) {
+            ewma_set_col_error(st->column, "not found");
+            return TF_ERROR;
+        }
+        if (st->missing == EWMA_MISSING_IGNORE) return ewma_passthrough(in, out);
+        force_null = 1;
+    } else if (!ewma_is_numeric_type(in->col_types[ci])) {
+        if (st->on_type_error == EWMA_TYPE_FAIL) {
+            ewma_set_col_error(st->column, "must be numeric");
+            return TF_ERROR;
+        }
+        force_null = 1;
+    }
+
+    const char *extra_names[1] = {st->result};
+    tf_type extra_types[1] = {TF_TYPE_FLOAT64};
     tf_batch *ob = tf_batch_create(in->n_cols + 1, in->n_rows);
     if (!ob) return TF_ERROR;
-    for (size_t c = 0; c < in->n_cols; c++)
-        tf_batch_set_schema(ob, c, in->col_names[c], in->col_types[c]);
-    tf_batch_set_schema(ob, in->n_cols, st->result, TF_TYPE_FLOAT64);
-
-    int ci = tf_batch_col_index(in, st->column);
+    if (tf_batch_clone_with_extra_cols(ob, in, extra_names, extra_types, 1) != TF_OK) {
+        tf_batch_free(ob);
+        return TF_ERROR;
+    }
 
     for (size_t r = 0; r < in->n_rows; r++) {
-        tf_batch_copy_row(ob, r, in, r);
+        if (tf_batch_copy_row(ob, r, in, r) != TF_OK) {
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
 
-        if (ci < 0 || tf_batch_is_null(in, r, ci)) {
-            tf_batch_set_null(ob, r, in->n_cols);
-            ob->n_rows = r + 1;
+        if (force_null || tf_batch_is_null(in, r, ci)) {
+            if (tf_batch_set_null(ob, r, in->n_cols) != TF_OK) { tf_batch_free(ob); return TF_ERROR; }
+            if (tf_batch_expose_row(ob, r) != TF_OK) { tf_batch_free(ob); return TF_ERROR; }
             continue;
         }
 
-        double val = get_numeric(in, r, ci);
-        if (!st->initialized) {
-            st->ewma = val;
-            st->initialized = 1;
-        } else {
-            st->ewma = st->alpha * val + (1.0 - st->alpha) * st->ewma;
-        }
+        double val = ewma_get_numeric(in, r, ci);
+        double next_ewma = st->initialized
+            ? st->alpha * val + (1.0 - st->alpha) * st->ewma
+            : val;
 
-        tf_batch_set_float64(ob, r, in->n_cols, st->ewma);
-        ob->n_rows = r + 1;
+        if (tf_batch_set_float64(ob, r, in->n_cols, next_ewma) != TF_OK) {
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
+        if (tf_batch_expose_row(ob, r) != TF_OK) {
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
+        st->ewma = next_ewma;
+        st->initialized = 1;
     }
 
     *out = ob;
@@ -77,23 +182,37 @@ tf_step *tf_ewma_create(const cJSON *args) {
     if (!args) return NULL;
     cJSON *col_j = cJSON_GetObjectItemCaseSensitive(args, "column");
     cJSON *alpha_j = cJSON_GetObjectItemCaseSensitive(args, "alpha");
-    if (!cJSON_IsString(col_j) || !cJSON_IsNumber(alpha_j)) return NULL;
+    if (!cJSON_IsString(col_j) || !col_j->valuestring[0] || !cJSON_IsNumber(alpha_j)) {
+        tf_set_last_error("ewma: column and alpha are required");
+        return NULL;
+    }
+    double alpha = alpha_j->valuedouble;
+    if (!isfinite(alpha) || alpha < 0.0 || alpha > 1.0) {
+        tf_set_last_error("ewma: alpha must be a finite number between 0 and 1");
+        return NULL;
+    }
 
-    ewma_state *st = calloc(1, sizeof(ewma_state));
+    ewma_state *st = tf_callocarray_checked(1, sizeof(ewma_state));
     if (!st) return NULL;
-    st->column = strdup(col_j->valuestring);
-    st->alpha = alpha_j->valuedouble;
+    st->column = tf_strdup_checked(col_j->valuestring);
+    st->alpha = alpha;
+    if (!st->column) { free(st); return NULL; }
+    if (ewma_parse_missing_policy(args, &st->missing) != TF_OK ||
+        ewma_parse_type_policy(args, &st->on_type_error) != TF_OK) {
+        free(st->column);
+        free(st);
+        return NULL;
+    }
 
     cJSON *res_j = cJSON_GetObjectItemCaseSensitive(args, "result");
     if (cJSON_IsString(res_j)) {
-        st->result = strdup(res_j->valuestring);
+        st->result = tf_strdup_checked(res_j->valuestring);
     } else {
-        char buf[256];
-        snprintf(buf, sizeof(buf), "%s_ewma", st->column);
-        st->result = strdup(buf);
+        st->result = tf_string_append_suffix_checked(st->column, "_ewma");
     }
+    if (!st->result) { free(st->column); free(st); return NULL; }
 
-    tf_step *step = malloc(sizeof(tf_step));
+    tf_step *step = tf_callocarray_checked(1, sizeof(tf_step));
     if (!step) { free(st->column); free(st->result); free(st); return NULL; }
     step->process = ewma_process;
     step->flush = ewma_flush;

package/csrc/op_explode.c

@@ -1,19 +1,31 @@
 /*
- * op_explode.c — Split delimited string into multiple rows.
+ * op_explode.c -- Split delimited string into multiple rows.
  *
- * Config: {"column": "tags", "delimiter": ","}
+ * Config: {"column": "tags", "delimiter": ",", "max_tokens_per_row": 1024}
  */
 
 #include "internal.h"
 #include "cJSON.h"
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 typedef struct {
     char *column;
     char *delimiter;
+    size_t max_tokens_per_row;
+    size_t max_output_rows_per_input_row;
+    size_t max_output_rows_per_batch;
+    size_t max_token_bytes;
 } explode_state;
 
+static int explode_set_cap_error(const char *name, size_t limit) {
+    char msg[160];
+    snprintf(msg, sizeof(msg), "explode: %s=%zu exceeded", name, limit);
+    tf_set_last_error(msg);
+    return TF_ERROR;
+}
+
 static int explode_process(tf_step *self, tf_batch *in, tf_batch **out,
                            tf_side_channels *side) {
     (void)side;
@@ -22,46 +34,103 @@ static int explode_process(tf_step *self, tf_batch *in, tf_batch **out,
 
     int ci = tf_batch_col_index(in, st->column);
 
-    /* Estimate max output rows */
-    size_t max_out = in->n_rows * 4;
-    tf_batch *ob = tf_batch_create(in->n_cols, max_out > 0 ? max_out : 16);
+    size_t initial_cap = in->n_rows ? in->n_rows : 1;
+    if (initial_cap > st->max_output_rows_per_batch)
+        initial_cap = st->max_output_rows_per_batch;
+    if (initial_cap < 16 && st->max_output_rows_per_batch >= 16)
+        initial_cap = 16;
+    tf_batch *ob = tf_batch_create(in->n_cols, initial_cap);
     if (!ob) return TF_ERROR;
-    for (size_t c = 0; c < in->n_cols; c++)
-        tf_batch_set_schema(ob, c, in->col_names[c], in->col_types[c]);
+    if (tf_batch_clone_schema(ob, in) != TF_OK) {
+        tf_batch_free(ob);
+        return TF_ERROR;
+    }
 
     size_t out_row = 0;
     size_t delim_len = strlen(st->delimiter);
 
     for (size_t r = 0; r < in->n_rows; r++) {
         if (ci < 0 || tf_batch_is_null(in, r, ci) || in->col_types[ci] != TF_TYPE_STRING) {
-            tf_batch_copy_row(ob, out_row, in, r);
-            ob->n_rows = ++out_row;
+            if (out_row >= st->max_output_rows_per_batch) {
+                explode_set_cap_error("max_output_rows_per_batch", st->max_output_rows_per_batch);
+                tf_batch_free(ob);
+                return TF_ERROR;
+            }
+            if (tf_batch_copy_row(ob, out_row, in, r) != TF_OK) {
+                tf_batch_free(ob);
+                return TF_ERROR;
+            }
+            if (tf_batch_expose_row(ob, out_row) != TF_OK) {
+                tf_batch_free(ob);
+                return TF_ERROR;
+            }
+            out_row++;
             continue;
         }
 
         const char *val = tf_batch_get_string(in, r, ci);
         const char *p = val;
+        size_t row_outputs = 0;
 
         while (*p) {
+            if (row_outputs >= st->max_tokens_per_row) {
+                explode_set_cap_error("max_tokens_per_row", st->max_tokens_per_row);
+                tf_batch_free(ob);
+                return TF_ERROR;
+            }
+            if (row_outputs >= st->max_output_rows_per_input_row) {
+                explode_set_cap_error("max_output_rows_per_input_row", st->max_output_rows_per_input_row);
+                tf_batch_free(ob);
+                return TF_ERROR;
+            }
+            if (out_row >= st->max_output_rows_per_batch) {
+                explode_set_cap_error("max_output_rows_per_batch", st->max_output_rows_per_batch);
+                tf_batch_free(ob);
+                return TF_ERROR;
+            }
+
             const char *found = strstr(p, st->delimiter);
             size_t tok_len = found ? (size_t)(found - p) : strlen(p);
-
-            tf_batch_copy_row(ob, out_row, in, r);
+            if (tok_len > st->max_token_bytes) {
+                explode_set_cap_error("max_token_bytes", st->max_token_bytes);
+                tf_batch_free(ob);
+                return TF_ERROR;
+            }
+            if (tf_batch_copy_row(ob, out_row, in, r) != TF_OK) {
+                tf_batch_free(ob);
+                return TF_ERROR;
+            }
             /* Override the exploded column */
-            char *tok = malloc(tok_len + 1);
-            if (tok) {
-                memcpy(tok, p, tok_len);
-                tok[tok_len] = '\0';
-                /* Trim leading/trailing whitespace */
-                char *s = tok;
-                while (*s == ' ') s++;
-                char *e = s + strlen(s);
-                while (e > s && *(e - 1) == ' ') e--;
-                *e = '\0';
-                tf_batch_set_string(ob, out_row, ci, s);
+            size_t tok_cap = 0;
+            if (tf_size_add(tok_len, 1, &tok_cap) != TF_OK) {
+                tf_batch_free(ob);
+                return TF_ERROR;
+            }
+            char *tok = malloc(tok_cap);
+            if (!tok) {
+                tf_batch_free(ob);
+                return TF_ERROR;
+            }
+            memcpy(tok, p, tok_len);
+            tok[tok_len] = '\0';
+            /* Trim leading/trailing whitespace */
+            char *s = tok;
+            while (*s == ' ') s++;
+            char *e = s + strlen(s);
+            while (e > s && *(e - 1) == ' ') e--;
+            *e = '\0';
+            if (tf_batch_set_string(ob, out_row, (size_t)ci, s) != TF_OK) {
                 free(tok);
+                tf_batch_free(ob);
+                return TF_ERROR;
+            }
+            free(tok);
+            if (tf_batch_expose_row(ob, out_row) != TF_OK) {
+                tf_batch_free(ob);
+                return TF_ERROR;
             }
-            ob->n_rows = ++out_row;
+            out_row++;
+            row_outputs++;
 
             if (found) p = found + delim_len;
             else break;
@@ -93,16 +162,45 @@ tf_step *tf_explode_create(const cJSON *args) {
 
     explode_state *st = calloc(1, sizeof(explode_state));
     if (!st) return NULL;
+    st->max_tokens_per_row = TF_MAX_EXPLODE_TOKENS_PER_ROW;
+    st->max_output_rows_per_input_row = TF_MAX_EXPANDING_ROWS_PER_INPUT;
+    st->max_output_rows_per_batch = TF_MAX_OUTPUT_ROWS_PER_BATCH;
+    st->max_token_bytes = TF_MAX_RECORD_BYTES;
+
+    size_t parsed_size = 0;
+    int has_size = tf_json_get_size_arg(args, "max_tokens_per_row", 1, TF_MAX_EXPLODE_TOKENS_PER_ROW, &parsed_size, "explode");
+    if (has_size < 0) goto fail;
+    if (has_size > 0) st->max_tokens_per_row = parsed_size;
+    has_size = tf_json_get_size_arg(args, "max_output_rows_per_input_row", 1, TF_MAX_EXPANDING_ROWS_PER_INPUT, &parsed_size, "explode");
+    if (has_size < 0) goto fail;
+    if (has_size > 0) st->max_output_rows_per_input_row = parsed_size;
+    has_size = tf_json_get_size_arg(args, "max_output_rows_per_batch", 1, TF_MAX_OUTPUT_ROWS_PER_BATCH, &parsed_size, "explode");
+    if (has_size < 0) goto fail;
+    if (has_size > 0) st->max_output_rows_per_batch = parsed_size;
+    has_size = tf_json_get_size_arg(args, "max_token_bytes", 0, TF_MAX_RECORD_BYTES, &parsed_size, "explode");
+    if (has_size < 0) goto fail;
+    if (has_size > 0) st->max_token_bytes = parsed_size;
+
     st->column = strdup(col_j->valuestring);
+    if (!st->column) goto fail;
 
     cJSON *delim_j = cJSON_GetObjectItemCaseSensitive(args, "delimiter");
-    st->delimiter = strdup(cJSON_IsString(delim_j) ? delim_j->valuestring : ",");
+    const char *delim = cJSON_IsString(delim_j) ? delim_j->valuestring : ",";
+    if (delim[0] == '\0') goto fail;
+    st->delimiter = strdup(delim);
+    if (!st->delimiter) goto fail;
 
-    tf_step *step = malloc(sizeof(tf_step));
-    if (!step) { free(st->column); free(st->delimiter); free(st); return NULL; }
+    tf_step *step = calloc(1, sizeof(tf_step));
+    if (!step) goto fail;
     step->process = explode_process;
     step->flush = explode_flush;
     step->destroy = explode_destroy;
     step->state = st;
     return step;
+
+fail:
+    free(st->column);
+    free(st->delimiter);
+    free(st);
+    return NULL;
 }