tranfi 0.0.2 → 0.2.0

package/csrc/op_tee.c

@@ -0,0 +1,338 @@
+/*
+ * op_tee.c -- Streaming side-channel row snapshots.
+ *
+ * Config: {
+ *   "expr": "optional row predicate",
+ *   "channel": "samples|errors|stats",
+ *   "columns": ["optional", "selectors"],
+ *   "limit": 1000,
+ *   "every": 1,
+ *   "name": "tee",
+ *   "include_row": true
+ * }
+ */
+
+#include "internal.h"
+#include "cJSON.h"
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct {
+    tf_expr *expr;
+    char    *expr_text;
+    char    *name;
+    char    *channel_name;
+    int      channel;
+    char   **selectors;
+    size_t   n_selectors;
+    int     *indices;
+    size_t   n_indices;
+    int      resolved;
+    size_t   limit;
+    size_t   every;
+    size_t   row_index;
+    size_t   emitted;
+    int      include_row;
+    tf_audit_options audit_opts;
+} tee_state;
+
+static int parse_channel(const char *s, int *out, const char **name_out) {
+    if (!s || !*s || strcmp(s, "samples") == 0 || strcmp(s, "sample") == 0) {
+        *out = TF_CHAN_SAMPLES;
+        *name_out = "samples";
+        return 1;
+    }
+    if (strcmp(s, "errors") == 0 || strcmp(s, "error") == 0) {
+        *out = TF_CHAN_ERRORS;
+        *name_out = "errors";
+        return 1;
+    }
+    if (strcmp(s, "stats") == 0 || strcmp(s, "audit") == 0) {
+        *out = TF_CHAN_STATS;
+        *name_out = strcmp(s, "audit") == 0 ? "audit" : "stats";
+        return 1;
+    }
+    return 0;
+}
+
+static tf_buffer *tee_side_buffer(tf_side_channels *side, int channel) {
+    if (!side) return NULL;
+    switch (channel) {
+        case TF_CHAN_ERRORS: return side->errors;
+        case TF_CHAN_STATS: return side->stats;
+        case TF_CHAN_SAMPLES: return side->samples;
+        default: return NULL;
+    }
+}
+
+static int tee_audit_column_allowed(const tee_state *st, const char *name) {
+    if (!st || st->audit_opts.n_columns == 0) return 1;
+    for (size_t i = 0; i < st->audit_opts.n_columns; i++) {
+        if (st->audit_opts.columns[i] && strcmp(st->audit_opts.columns[i], name ? name : "") == 0)
+            return 1;
+    }
+    return 0;
+}
+
+static cJSON *tee_selected_row_to_json(const tee_state *st, const tf_batch *in, size_t row) {
+    cJSON *data = cJSON_CreateObject();
+    if (!data) return NULL;
+    for (size_t i = 0; i < st->n_indices; i++) {
+        int ci = st->indices[i];
+        if (ci < 0 || (size_t)ci >= in->n_cols) continue;
+        const char *name = in->col_names[ci] ? in->col_names[ci] : "";
+        if (!tee_audit_column_allowed(st, name)) continue;
+        cJSON *value = tf_audit_cell_to_json(in, row, (size_t)ci, &st->audit_opts);
+        if (!value) { cJSON_Delete(data); return NULL; }
+        if (tf_json_add_item(data, name, value) != TF_OK) {
+            cJSON_Delete(data);
+            return NULL;
+        }
+    }
+    if (st->audit_opts.max_bytes > 0) {
+        char *printed = cJSON_PrintUnformatted(data);
+        if (!printed) { cJSON_Delete(data); return NULL; }
+        size_t n = strlen(printed);
+        free(printed);
+        if (n > st->audit_opts.max_bytes) {
+            cJSON_Delete(data);
+            data = cJSON_CreateObject();
+            if (!data) return NULL;
+            if (tf_json_add_bool(data, "_audit_truncated", 1) != TF_OK ||
+                tf_json_add_number(data, "max_bytes", (double)st->audit_opts.max_bytes) != TF_OK) {
+                cJSON_Delete(data);
+                return NULL;
+            }
+        }
+    }
+    return data;
+}
+
+static int tee_resolve_columns(tee_state *st, const tf_batch *in) {
+    if (st->resolved) return TF_OK;
+    free(st->indices);
+    st->indices = NULL;
+    st->n_indices = 0;
+
+    if (st->n_selectors == 0) {
+        st->indices = malloc((in->n_cols ? in->n_cols : 1) * sizeof(int));
+        if (!st->indices) return TF_ERROR;
+        for (size_t i = 0; i < in->n_cols; i++) st->indices[i] = (int)i;
+        st->n_indices = in->n_cols;
+        st->resolved = 1;
+        return TF_OK;
+    }
+
+    char *error = NULL;
+    if (tf_column_selectors_resolve(st->selectors, st->n_selectors,
+                                    in->col_names, in->col_types, in->n_cols,
+                                    &st->indices, &st->n_indices, &error) != TF_OK) {
+        char msg[512];
+        snprintf(msg, sizeof(msg), "tee: %s", error ? error : "invalid columns");
+        tf_set_last_error(msg);
+        free(error);
+        return TF_ERROR;
+    }
+    free(error);
+    st->resolved = 1;
+    return TF_OK;
+}
+
+static int tee_emit_row(tee_state *st, const tf_batch *in, size_t row,
+                        tf_side_channels *side) {
+    tf_buffer *buf = tee_side_buffer(side, st->channel);
+    if (!buf) return TF_OK;
+
+    cJSON *obj = cJSON_CreateObject();
+    if (!obj) return TF_ERROR;
+    int rc = TF_ERROR;
+    if (tf_json_add_string(obj, "type", "tee") != TF_OK ||
+        tf_json_add_string(obj, "op", "tee") != TF_OK ||
+        tf_json_add_string(obj, "name", st->name ? st->name : "tee") != TF_OK ||
+        tf_json_add_string(obj, "channel", st->channel_name ? st->channel_name : "samples") != TF_OK) {
+        goto done;
+    }
+    if (st->expr_text && st->expr_text[0] &&
+        tf_json_add_string(obj, "expr", st->expr_text) != TF_OK) {
+        goto done;
+    }
+    if (st->include_row && tf_json_add_number(obj, "row", (double)st->row_index) != TF_OK) goto done;
+
+    if (st->audit_opts.include_row) {
+        cJSON *data = tee_selected_row_to_json(st, in, row);
+        if (!data || tf_json_add_item(obj, "data", data) != TF_OK) goto done;
+    }
+
+    rc = tf_buffer_write_json_line(buf, obj);
+done:
+    cJSON_Delete(obj);
+    return rc;
+}
+
+static int tee_process(tf_step *self, tf_batch *in, tf_batch **out,
+                       tf_side_channels *side) {
+    tee_state *st = self->state;
+    *out = NULL;
+
+    if (tee_resolve_columns(st, in) != TF_OK) return TF_ERROR;
+
+    tf_batch *ob = tf_batch_create(in->n_cols, in->n_rows > 0 ? in->n_rows : 1);
+    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++) {
+        st->row_index++;
+        bool should_emit = true;
+        if (st->expr) {
+            if (tf_expr_eval(st->expr, in, r, &should_emit) != TF_OK) should_emit = false;
+        }
+        if (should_emit && st->every > 1 && ((st->row_index - 1) % st->every) != 0)
+            should_emit = false;
+        if (should_emit && st->emitted < st->limit) {
+            if (tee_emit_row(st, in, r, side) != TF_OK) { tf_batch_free(ob); return TF_ERROR; }
+            st->emitted++;
+        }
+        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 tee_flush(tf_step *self, tf_batch **out, tf_side_channels *side) {
+    (void)self; (void)side;
+    *out = NULL;
+    return TF_OK;
+}
+
+static void tee_state_free(tee_state *st) {
+    if (!st) return;
+    tf_expr_free(st->expr);
+    free(st->expr_text);
+    free(st->name);
+    free(st->channel_name);
+    tf_audit_options_free(&st->audit_opts);
+    for (size_t i = 0; i < st->n_selectors; i++) free(st->selectors[i]);
+    free(st->selectors);
+    free(st->indices);
+    free(st);
+}
+
+static void tee_destroy(tf_step *self) {
+    if (!self) return;
+    tee_state_free(self->state);
+    free(self);
+}
+
+static int tee_copy_columns_arg(tee_state *st, const cJSON *cols) {
+    if (!cols) return TF_OK;
+    if (!cJSON_IsArray(cols)) {
+        tf_set_last_error("tee: columns must be an array");
+        return TF_ERROR;
+    }
+    int n = cJSON_GetArraySize((cJSON *)cols);
+    if (n <= 0) return TF_OK;
+    st->selectors = calloc((size_t)n, sizeof(char *));
+    if (!st->selectors) return TF_ERROR;
+    st->n_selectors = (size_t)n;
+    for (int i = 0; i < n; i++) {
+        cJSON *item = cJSON_GetArrayItem((cJSON *)cols, i);
+        if (!cJSON_IsString(item) || !item->valuestring[0]) {
+            tf_set_last_error("tee: columns must contain non-empty strings");
+            return TF_ERROR;
+        }
+        st->selectors[i] = strdup(item->valuestring);
+        if (!st->selectors[i]) return TF_ERROR;
+    }
+    return TF_OK;
+}
+
+tf_step *tf_tee_create(const cJSON *args) {
+    if (!args) return NULL;
+
+    tee_state *st = calloc(1, sizeof(tee_state));
+    if (!st) return NULL;
+    st->limit = 1000;
+    st->every = 1;
+    st->include_row = 1;
+    tf_audit_options_init(&st->audit_opts, 1);
+
+    cJSON *expr_json = cJSON_GetObjectItemCaseSensitive(args, "expr");
+    if (cJSON_IsString(expr_json) && expr_json->valuestring[0]) {
+        st->expr = tf_expr_parse(expr_json->valuestring);
+        if (!st->expr) { tee_state_free(st); return NULL; }
+        st->expr_text = strdup(expr_json->valuestring);
+        if (!st->expr_text) { tee_state_free(st); return NULL; }
+    }
+
+    cJSON *channel_json = cJSON_GetObjectItemCaseSensitive(args, "channel");
+    const char *channel_name = NULL;
+    if (!parse_channel(cJSON_IsString(channel_json) ? channel_json->valuestring : NULL,
+                       &st->channel, &channel_name)) {
+        tf_set_last_error("tee: channel must be samples, errors, stats, or audit");
+        tee_state_free(st);
+        return NULL;
+    }
+    st->channel_name = strdup(channel_name);
+
+    cJSON *name_json = cJSON_GetObjectItemCaseSensitive(args, "name");
+    st->name = strdup(cJSON_IsString(name_json) && name_json->valuestring[0] ? name_json->valuestring : "tee");
+
+    cJSON *limit_json = cJSON_GetObjectItemCaseSensitive(args, "limit");
+    if (!limit_json) limit_json = cJSON_GetObjectItemCaseSensitive(args, "max_rows");
+    if (limit_json) {
+        size_t parsed_limit = 0;
+        if (tf_json_get_size_arg_any(args, "limit", "max_rows",
+                                     1, TF_MAX_AUDIT_RECORDS,
+                                     &parsed_limit, "tee") < 0) {
+            tee_state_free(st);
+            return NULL;
+        }
+        st->limit = parsed_limit;
+    }
+
+    cJSON *every_json = cJSON_GetObjectItemCaseSensitive(args, "every");
+    if (every_json) {
+        size_t parsed_every = 0;
+        if (tf_json_get_size_arg(args, "every", 1, TF_MAX_COUNT_ARG,
+                                 &parsed_every, "tee") < 0) {
+            tee_state_free(st);
+            return NULL;
+        }
+        st->every = parsed_every;
+    }
+
+    cJSON *include_json = cJSON_GetObjectItemCaseSensitive(args, "include_row");
+    if (!include_json) include_json = cJSON_GetObjectItemCaseSensitive(args, "includeRow");
+    if (include_json) st->include_row = cJSON_IsTrue(include_json);
+
+    cJSON *columns_json = cJSON_GetObjectItemCaseSensitive(args, "columns");
+    if (tee_copy_columns_arg(st, columns_json) != TF_OK) {
+        tee_state_free(st);
+        return NULL;
+    }
+
+    if (tf_audit_options_parse(&st->audit_opts, args, "tee") != TF_OK) {
+        tee_state_free(st);
+        return NULL;
+    }
+
+    if (!st->name || !st->channel_name) {
+        tee_state_free(st);
+        return NULL;
+    }
+
+    tf_step *step = calloc(1, sizeof(tf_step));
+    if (!step) {
+        tee_state_free(st);
+        return NULL;
+    }
+    step->process = tee_process;
+    step->flush = tee_flush;
+    step->destroy = tee_destroy;
+    step->state = st;
+    return step;
+}

package/csrc/op_top.c

@@ -0,0 +1,357 @@
+/*
+ * op_top.c — Heap-backed bounded top/bottom N rows by column.
+ *
+ * Config: {"n": 10, "column": "score", "desc": true}
+ */
+
+#include "internal.h"
+#include "cJSON.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct {
+    size_t    n;
+    char     *column;
+    int       desc;       /* 1 = highest first (default) */
+    tf_batch *buf;
+    size_t   *heap;       /* row indices in buf; root is worst retained row */
+    size_t    heap_len;
+    size_t    replacements_since_compact;
+    int       has_schema;
+    int       col_idx;
+} top_state;
+
+static int top_compare_cells(const tf_batch *a, size_t ra,
+                             const tf_batch *b, size_t rb,
+                             int ci, int desc) {
+    int null_a = tf_batch_is_null(a, ra, ci);
+    int null_b = tf_batch_is_null(b, rb, ci);
+
+    /* Match sort semantics: nulls rank last for both ascending and descending. */
+    if (null_a && null_b) return 0;
+    if (null_a) return 1;
+    if (null_b) return -1;
+
+    int cmp = 0;
+    switch (a->col_types[ci]) {
+        case TF_TYPE_BOOL: {
+            bool va = tf_batch_get_bool(a, ra, ci);
+            bool vb = tf_batch_get_bool(b, rb, ci);
+            cmp = (int)va - (int)vb;
+            break;
+        }
+        case TF_TYPE_INT64: {
+            int64_t va = tf_batch_get_int64(a, ra, ci);
+            int64_t vb = tf_batch_get_int64(b, rb, ci);
+            cmp = (va > vb) - (va < vb);
+            break;
+        }
+        case TF_TYPE_FLOAT64: {
+            double va = tf_batch_get_float64(a, ra, ci);
+            double vb = tf_batch_get_float64(b, rb, ci);
+            cmp = (va > vb) - (va < vb);
+            break;
+        }
+        case TF_TYPE_STRING:
+            cmp = strcmp(tf_batch_get_string(a, ra, ci),
+                         tf_batch_get_string(b, rb, ci));
+            break;
+        case TF_TYPE_DATE: {
+            int32_t va = tf_batch_get_date(a, ra, ci);
+            int32_t vb = tf_batch_get_date(b, rb, ci);
+            cmp = (va > vb) - (va < vb);
+            break;
+        }
+        case TF_TYPE_TIMESTAMP: {
+            int64_t va = tf_batch_get_timestamp(a, ra, ci);
+            int64_t vb = tf_batch_get_timestamp(b, rb, ci);
+            cmp = (va > vb) - (va < vb);
+            break;
+        }
+        default:
+            break;
+    }
+
+    return desc ? -cmp : cmp;
+}
+
+static int top_heap_worse(const top_state *st, size_t a, size_t b) {
+    return top_compare_cells(st->buf, a, st->buf, b, st->col_idx, st->desc) > 0;
+}
+
+static void top_heap_swap(size_t *a, size_t *b) {
+    size_t tmp = *a;
+    *a = *b;
+    *b = tmp;
+}
+
+static void top_heap_sift_up(top_state *st, size_t pos) {
+    while (pos > 0) {
+        size_t parent = (pos - 1) / 2;
+        if (!top_heap_worse(st, st->heap[pos], st->heap[parent])) break;
+        top_heap_swap(&st->heap[pos], &st->heap[parent]);
+        pos = parent;
+    }
+}
+
+static void top_heap_sift_down(top_state *st, size_t pos) {
+    for (;;) {
+        size_t left = pos * 2 + 1;
+        size_t right = left + 1;
+        size_t worst = pos;
+
+        if (left < st->heap_len && top_heap_worse(st, st->heap[left], st->heap[worst])) {
+            worst = left;
+        }
+        if (right < st->heap_len && top_heap_worse(st, st->heap[right], st->heap[worst])) {
+            worst = right;
+        }
+        if (worst == pos) break;
+        top_heap_swap(&st->heap[pos], &st->heap[worst]);
+        pos = worst;
+    }
+}
+
+static void top_heap_push(top_state *st, size_t row) {
+    st->heap[st->heap_len] = row;
+    top_heap_sift_up(st, st->heap_len);
+    st->heap_len++;
+}
+
+static void top_heap_rebuild(top_state *st) {
+    st->heap_len = 0;
+    for (size_t r = 0; r < st->buf->n_rows; r++) {
+        top_heap_push(st, r);
+    }
+}
+
+static int top_compact_buffer(top_state *st) {
+    if (!st->buf) return TF_OK;
+
+    tf_batch *old = st->buf;
+    size_t cap = st->n > 0 ? st->n : 1;
+    tf_batch *nb = tf_batch_create(old->n_cols, cap);
+    if (!nb) return TF_ERROR;
+
+    if (tf_batch_clone_schema(nb, old) != TF_OK) {
+        tf_batch_free(nb);
+        return TF_ERROR;
+    }
+    for (size_t r = 0; r < old->n_rows; r++) {
+        if (tf_batch_copy_row(nb, r, old, r) != TF_OK) {
+            tf_batch_free(nb);
+            return TF_ERROR;
+        }
+        if (tf_batch_expose_row(nb, r) != TF_OK) {
+            tf_batch_free(nb);
+            return TF_ERROR;
+        }
+    }
+
+    st->buf = nb;
+    tf_batch_free(old);
+    top_heap_rebuild(st);
+    st->replacements_since_compact = 0;
+    return TF_OK;
+}
+
+static int top_init_schema(top_state *st, const tf_batch *in) {
+    size_t cap = st->n > 0 ? st->n : 1;
+    tf_batch *buf = tf_batch_create(in->n_cols, cap);
+    if (!buf) return TF_ERROR;
+
+    size_t *heap = NULL;
+    if (st->n > 0) {
+        heap = calloc(st->n, sizeof(size_t));
+        if (!heap) {
+            tf_batch_free(buf);
+            return TF_ERROR;
+        }
+    }
+
+    int col_idx = tf_batch_col_index(in, st->column);
+    if (col_idx < 0) {
+        char msg[256];
+        snprintf(msg, sizeof(msg), "top: column '%s' not found", st->column ? st->column : "");
+        tf_set_last_error(msg);
+        free(heap);
+        tf_batch_free(buf);
+        return TF_ERROR;
+    }
+
+    if (tf_batch_clone_schema(buf, in) != TF_OK) {
+        free(heap);
+        tf_batch_free(buf);
+        return TF_ERROR;
+    }
+
+    st->buf = buf;
+    st->heap = heap;
+    st->col_idx = col_idx;
+    st->has_schema = 1;
+    return TF_OK;
+}
+
+static int top_process(tf_step *self, tf_batch *in, tf_batch **out,
+                       tf_side_channels *side) {
+    (void)side;
+    top_state *st = self->state;
+    *out = NULL;
+
+    if (!st->has_schema) {
+        if (top_init_schema(st, in) != TF_OK) return TF_ERROR;
+    }
+
+    if (st->n == 0) return TF_OK;
+
+    int ci = st->col_idx;
+    for (size_t r = 0; r < in->n_rows; r++) {
+        if (st->buf->n_rows < st->n) {
+            size_t dst = st->buf->n_rows;
+            if (tf_batch_copy_row(st->buf, dst, in, r) != TF_OK) return TF_ERROR;
+            if (tf_batch_expose_row(st->buf, dst) != TF_OK) return TF_ERROR;
+            top_heap_push(st, dst);
+        } else {
+            size_t worst_idx = st->heap[0];
+            if (top_compare_cells(in, r, st->buf, worst_idx, ci, st->desc) < 0) {
+                if (tf_batch_copy_row(st->buf, worst_idx, in, r) != TF_OK) return TF_ERROR;
+                top_heap_sift_down(st, 0);
+                st->replacements_since_compact++;
+                size_t compact_every = st->n < 4096 ? st->n : 4096;
+                if (compact_every > 0 && st->replacements_since_compact >= compact_every) {
+                    if (top_compact_buffer(st) != TF_OK) return TF_ERROR;
+                }
+            }
+        }
+    }
+
+    return TF_OK;
+}
+
+typedef struct {
+    const tf_batch *batch;
+    int col_idx;
+    int desc;
+} top_sort_ctx;
+
+static int top_sort_cmp(const top_sort_ctx *ctx, size_t a, size_t b) {
+    return top_compare_cells(ctx->batch, a, ctx->batch, b, ctx->col_idx, ctx->desc);
+}
+
+static int top_sort_cmp_index(const void *ctx, size_t a, size_t b) {
+    return top_sort_cmp((const top_sort_ctx *)ctx, a, b);
+}
+
+static int top_flush(tf_step *self, tf_batch **out, tf_side_channels *side) {
+    (void)side;
+    top_state *st = self->state;
+    *out = NULL;
+
+    if (!st->buf || st->buf->n_rows == 0) return TF_OK;
+
+    /* Sort the buffer */
+    size_t n = st->buf->n_rows;
+    size_t *indices = malloc(n * sizeof(size_t));
+    if (!indices) return TF_ERROR;
+    for (size_t i = 0; i < n; i++) indices[i] = i;
+
+    top_sort_ctx ctx = { .batch = st->buf, .col_idx = st->col_idx, .desc = st->desc };
+    tf_sort_indices(indices, n, top_sort_cmp_index, &ctx);
+
+    tf_batch *ob = tf_batch_create(st->buf->n_cols, n);
+    if (!ob) { free(indices); return TF_ERROR; }
+    if (tf_batch_clone_schema(ob, st->buf) != TF_OK) {
+        free(indices);
+        tf_batch_free(ob);
+        return TF_ERROR;
+    }
+    for (size_t i = 0; i < n; i++) {
+        if (tf_batch_copy_row(ob, i, st->buf, indices[i]) != TF_OK) {
+            free(indices);
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
+        if (tf_batch_expose_row(ob, i) != TF_OK) {
+            free(indices);
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
+    }
+
+    free(indices);
+    *out = ob;
+    return TF_OK;
+}
+
+static void top_destroy(tf_step *self) {
+    top_state *st = self->state;
+    if (st) {
+        free(st->column);
+        free(st->heap);
+        if (st->buf) tf_batch_free(st->buf);
+        free(st);
+    }
+    free(self);
+}
+
+tf_step *tf_top_create(const cJSON *args) {
+    if (!args) return NULL;
+    cJSON *col_j = cJSON_GetObjectItemCaseSensitive(args, "column");
+    size_t n = 0;
+    int has_n = tf_json_get_size_arg(args, "n", 0, TF_MAX_OUTPUT_ROWS_PER_BATCH, &n, "top");
+    if (has_n <= 0) return NULL;
+    if (!cJSON_IsString(col_j) || !col_j->valuestring || col_j->valuestring[0] == '\0') {
+        tf_set_last_error("top: column must be a non-empty string");
+        return NULL;
+    }
+
+    top_state *st = calloc(1, sizeof(top_state));
+    if (!st) return NULL;
+    st->n = n;
+    st->col_idx = -1;
+    st->column = strdup(col_j->valuestring);
+    if (!st->column) { free(st); return NULL; }
+
+    cJSON *desc_j = cJSON_GetObjectItemCaseSensitive(args, "desc");
+    st->desc = (desc_j && cJSON_IsBool(desc_j)) ? cJSON_IsTrue(desc_j) : 1; /* default desc */
+
+    tf_step *step = calloc(1, sizeof(tf_step));
+    if (!step) { free(st->column); free(st); return NULL; }
+    step->process = top_process;
+    step->flush = top_flush;
+    step->destroy = top_destroy;
+    step->state = st;
+    return step;
+}
+
+static tf_step *top_create_with_default_desc(const cJSON *args, int default_desc) {
+    if (!args) return NULL;
+    cJSON *copy = cJSON_Duplicate(args, 1);
+    if (!copy) return NULL;
+    if (!cJSON_GetObjectItemCaseSensitive(copy, "desc")) {
+        if (tf_json_add_bool(copy, "desc", default_desc) != TF_OK) {
+            cJSON_Delete(copy);
+            return NULL;
+        }
+    }
+    tf_step *step = tf_top_create(copy);
+    cJSON_Delete(copy);
+    return step;
+}
+
+tf_step *tf_top_k_create(const cJSON *args) {
+    return top_create_with_default_desc(args, 1);
+}
+
+tf_step *tf_bottom_k_create(const cJSON *args) {
+    return top_create_with_default_desc(args, 0);
+}
+
+tf_step *tf_slice_min_create(const cJSON *args) {
+    return top_create_with_default_desc(args, 0);
+}
+
+tf_step *tf_slice_max_create(const cJSON *args) {
+    return top_create_with_default_desc(args, 1);
+}