tranfi 0.0.1 → 0.1.2

package/csrc/expr.h

@@ -0,0 +1,56 @@
+/*
+ * expr.h — Expression AST types (shared between expr.c and ir_sql.c).
+ */
+
+#ifndef TF_EXPR_H
+#define TF_EXPR_H
+
+#include <stdint.h>
+
+typedef enum {
+  EXPR_LIT_INT,
+  EXPR_LIT_FLOAT,
+  EXPR_LIT_STR,
+  EXPR_COL_REF,
+  EXPR_CMP,
+  EXPR_AND,
+  EXPR_OR,
+  EXPR_NOT,
+  EXPR_ADD,
+  EXPR_SUB,
+  EXPR_MUL,
+  EXPR_DIV,
+  EXPR_NEG,
+  EXPR_FUNC_CALL,
+} expr_kind;
+
+typedef enum {
+  CMP_GT, CMP_GE, CMP_LT, CMP_LE, CMP_EQ, CMP_NE,
+} cmp_op;
+
+struct tf_expr {
+  expr_kind kind;
+  union {
+    int64_t lit_int;
+    double  lit_float;
+    char   *lit_str;
+    char   *col_name;    /* for EXPR_COL_REF */
+    struct {              /* for EXPR_CMP */
+      struct tf_expr *left;
+      struct tf_expr *right;
+      cmp_op op;
+    } cmp;
+    struct {              /* for EXPR_AND, EXPR_OR, EXPR_ADD, EXPR_SUB, EXPR_MUL, EXPR_DIV */
+      struct tf_expr *left;
+      struct tf_expr *right;
+    } binary;
+    struct tf_expr *child; /* for EXPR_NOT, EXPR_NEG */
+    struct {              /* for EXPR_FUNC_CALL */
+      char *name;
+      struct tf_expr **args;
+      int n_args;
+    } func;
+  };
+};
+
+#endif /* TF_EXPR_H */

package/csrc/internal.h

@@ -0,0 +1,250 @@
+/*
+ * internal.h — Internal types for the Tranfi core.
+ * Not part of the public API.
+ */
+
+#ifndef TF_INTERNAL_H
+#define TF_INTERNAL_H
+
+#include "tranfi.h"
+#include "ir.h"
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+/* ---- Arena allocator ---- */
+
+typedef struct tf_arena_block {
+    uint8_t *data;
+    size_t   used;
+    size_t   cap;
+    struct tf_arena_block *next;
+} tf_arena_block;
+
+typedef struct tf_arena {
+    tf_arena_block *head;
+    tf_arena_block *current;
+    size_t          block_size; /* default block capacity */
+} tf_arena;
+
+tf_arena *tf_arena_create(size_t block_size);
+void     *tf_arena_alloc(tf_arena *a, size_t size);
+char     *tf_arena_strdup(tf_arena *a, const char *s);
+void      tf_arena_reset(tf_arena *a);
+void      tf_arena_free(tf_arena *a);
+
+/* ---- Growable byte buffer ---- */
+
+typedef struct tf_buffer {
+    uint8_t *data;
+    size_t   len;      /* bytes written */
+    size_t   cap;      /* allocated capacity */
+    size_t   read_pos; /* consumer read position */
+} tf_buffer;
+
+void   tf_buffer_init(tf_buffer *b);
+int    tf_buffer_write(tf_buffer *b, const uint8_t *data, size_t len);
+size_t tf_buffer_read(tf_buffer *b, uint8_t *out, size_t len);
+size_t tf_buffer_readable(const tf_buffer *b);
+void   tf_buffer_compact(tf_buffer *b);
+int    tf_buffer_write_str(tf_buffer *b, const char *s);
+void   tf_buffer_free(tf_buffer *b);
+
+/* ---- Columnar batch ---- */
+/* (tf_type is defined in ir.h, included above) */
+
+typedef struct tf_batch {
+    char       **col_names;  /* array of column name strings (arena-allocated) */
+    tf_type     *col_types;  /* per-column type */
+    size_t       n_cols;
+    size_t       n_rows;
+    size_t       capacity;   /* allocated row slots per column */
+    void       **columns;    /* array of typed column arrays */
+    uint8_t    **nulls;      /* null bitmap per column (1 byte per row for simplicity) */
+    tf_arena    *arena;      /* owns all memory for this batch */
+} tf_batch;
+
+tf_batch *tf_batch_create(size_t n_cols, size_t capacity);
+int       tf_batch_set_schema(tf_batch *b, size_t col, const char *name, tf_type type);
+int       tf_batch_ensure_capacity(tf_batch *b, size_t min_rows);
+
+/* Set a value in a specific cell. String values are copied into the arena. */
+void tf_batch_set_null(tf_batch *b, size_t row, size_t col);
+void tf_batch_set_bool(tf_batch *b, size_t row, size_t col, bool val);
+void tf_batch_set_int64(tf_batch *b, size_t row, size_t col, int64_t val);
+void tf_batch_set_float64(tf_batch *b, size_t row, size_t col, double val);
+void tf_batch_set_string(tf_batch *b, size_t row, size_t col, const char *val);
+void tf_batch_set_date(tf_batch *b, size_t row, size_t col, int32_t val);
+void tf_batch_set_timestamp(tf_batch *b, size_t row, size_t col, int64_t val);
+
+/* Get values from a cell. */
+bool      tf_batch_is_null(const tf_batch *b, size_t row, size_t col);
+bool      tf_batch_get_bool(const tf_batch *b, size_t row, size_t col);
+int64_t   tf_batch_get_int64(const tf_batch *b, size_t row, size_t col);
+double    tf_batch_get_float64(const tf_batch *b, size_t row, size_t col);
+const char *tf_batch_get_string(const tf_batch *b, size_t row, size_t col);
+int32_t   tf_batch_get_date(const tf_batch *b, size_t row, size_t col);
+int64_t   tf_batch_get_timestamp(const tf_batch *b, size_t row, size_t col);
+
+/* Find column index by name. Returns -1 if not found. */
+int tf_batch_col_index(const tf_batch *b, const char *name);
+
+/* Copy a single row from src to dst batch. */
+int tf_batch_copy_row(tf_batch *dst, size_t dst_row,
+                      const tf_batch *src, size_t src_row);
+
+void tf_batch_free(tf_batch *b);
+
+/* ---- Step interface (transforms) ---- */
+
+/*
+ * Side-channel callback: steps call this to emit data to side channels.
+ * Owned by the pipeline and passed to steps during processing.
+ */
+typedef struct tf_side_channels {
+    tf_buffer *errors;
+    tf_buffer *stats;
+    tf_buffer *samples;
+} tf_side_channels;
+
+typedef struct tf_step {
+    /* Process one input batch, produce zero or one output batch.
+     * *out is set to a new batch (caller frees) or NULL if filtered away. */
+    int  (*process)(struct tf_step *self, tf_batch *in, tf_batch **out,
+                    tf_side_channels *side);
+    /* Flush any buffered state. */
+    int  (*flush)(struct tf_step *self, tf_batch **out, tf_side_channels *side);
+    /* Free all resources. */
+    void (*destroy)(struct tf_step *self);
+    void  *state;
+} tf_step;
+
+/* ---- Decoder interface (bytes → batches) ---- */
+
+typedef struct tf_decoder {
+    /*
+     * Decode bytes. May produce 0..N batches.
+     * *out is set to a malloc'd array of tf_batch*, *n_out to its length.
+     * Caller frees the array and each batch.
+     */
+    int  (*decode)(struct tf_decoder *self, const uint8_t *data, size_t len,
+                   tf_batch ***out, size_t *n_out);
+    /* Flush remaining data (e.g. last partial line). */
+    int  (*flush)(struct tf_decoder *self, tf_batch ***out, size_t *n_out);
+    void (*destroy)(struct tf_decoder *self);
+    void  *state;
+} tf_decoder;
+
+/* ---- Encoder interface (batches → bytes) ---- */
+
+typedef struct tf_encoder {
+    /*
+     * Encode a batch to bytes. Appends to the provided buffer.
+     */
+    int  (*encode)(struct tf_encoder *self, tf_batch *in, tf_buffer *out);
+    /* Flush any trailing data. */
+    int  (*flush)(struct tf_encoder *self, tf_buffer *out);
+    void (*destroy)(struct tf_encoder *self);
+    void  *state;
+} tf_encoder;
+
+/* ---- Pipeline struct ---- */
+
+struct tf_pipeline {
+    tf_decoder  *decoder;
+    tf_step    **steps;
+    size_t       n_steps;
+    tf_encoder  *encoder;
+    tf_buffer    output[TF_NUM_CHANNELS];
+    tf_side_channels side;
+    size_t       rows_in;
+    size_t       rows_out;
+    size_t       bytes_in;
+    size_t       bytes_out;
+    char        *error;
+    int          finished;
+};
+
+/* ---- Codec constructors (used by plan parser) ---- */
+
+typedef struct cJSON cJSON;
+
+tf_decoder *tf_csv_decoder_create(const cJSON *args);
+tf_encoder *tf_csv_encoder_create(const cJSON *args);
+tf_decoder *tf_jsonl_decoder_create(const cJSON *args);
+tf_encoder *tf_jsonl_encoder_create(const cJSON *args);
+tf_decoder *tf_text_decoder_create(const cJSON *args);
+tf_encoder *tf_text_encoder_create(const cJSON *args);
+
+/* ---- Transform constructors ---- */
+
+tf_step *tf_filter_create(const cJSON *args);
+tf_step *tf_select_create(const cJSON *args);
+tf_step *tf_rename_create(const cJSON *args);
+tf_step *tf_head_create(const cJSON *args);
+tf_step *tf_skip_create(const cJSON *args);
+tf_step *tf_derive_create(const cJSON *args);
+tf_step *tf_stats_create(const cJSON *args);
+tf_step *tf_unique_create(const cJSON *args);
+tf_step *tf_sort_create(const cJSON *args);
+tf_step *tf_validate_create(const cJSON *args);
+tf_step *tf_trim_create(const cJSON *args);
+tf_step *tf_fill_null_create(const cJSON *args);
+tf_step *tf_cast_create(const cJSON *args);
+tf_step *tf_clip_create(const cJSON *args);
+tf_step *tf_replace_create(const cJSON *args);
+tf_step *tf_hash_create(const cJSON *args);
+tf_step *tf_bin_create(const cJSON *args);
+tf_step *tf_fill_down_create(const cJSON *args);
+tf_step *tf_step_create(const cJSON *args);
+tf_step *tf_window_create(const cJSON *args);
+tf_step *tf_explode_create(const cJSON *args);
+tf_step *tf_split_create(const cJSON *args);
+tf_step *tf_unpivot_create(const cJSON *args);
+tf_step *tf_tail_create(const cJSON *args);
+tf_step *tf_top_create(const cJSON *args);
+tf_step *tf_sample_create(const cJSON *args);
+tf_step *tf_group_agg_create(const cJSON *args);
+tf_step *tf_frequency_create(const cJSON *args);
+tf_step *tf_datetime_create(const cJSON *args);
+tf_step *tf_grep_create(const cJSON *args);
+tf_step *tf_pivot_create(const cJSON *args);
+tf_step *tf_join_create(const cJSON *args);
+tf_step *tf_stack_create(const cJSON *args);
+tf_step *tf_lead_create(const cJSON *args);
+tf_step *tf_date_trunc_create(const cJSON *args);
+tf_step *tf_onehot_create(const cJSON *args);
+tf_step *tf_label_encode_create(const cJSON *args);
+tf_step *tf_ewma_create(const cJSON *args);
+tf_step *tf_diff_create(const cJSON *args);
+tf_step *tf_anomaly_create(const cJSON *args);
+tf_step *tf_split_data_create(const cJSON *args);
+tf_step *tf_interpolate_create(const cJSON *args);
+tf_step *tf_normalize_create(const cJSON *args);
+tf_step *tf_acf_create(const cJSON *args);
+
+/* ---- Table encoder ---- */
+
+tf_encoder *tf_table_encoder_create(const cJSON *args);
+
+/* ---- Expression evaluator ---- */
+
+typedef struct tf_expr tf_expr;
+
+tf_expr    *tf_expr_parse(const char *text);
+int         tf_expr_eval(const tf_expr *e, const tf_batch *batch, size_t row, bool *result);
+int         tf_expr_eval_val(const tf_expr *e, const tf_batch *batch, size_t row,
+                             tf_eval_result *result);
+void        tf_expr_free(tf_expr *e);
+
+/* ---- Plan parser ---- */
+
+int tf_plan_parse(const char *json, size_t len,
+                  tf_decoder **decoder, tf_step ***steps, size_t *n_steps,
+                  tf_encoder **encoder, char **error);
+
+/* ---- Global error ---- */
+
+void tf_set_last_error(const char *msg);
+
+#endif /* TF_INTERNAL_H */

package/csrc/ir.c

@@ -0,0 +1,119 @@
+/*
+ * ir.c — IR plan construction, cloning, and memory management.
+ */
+
+#include "ir.h"
+#include "cJSON.h"
+#include <stdlib.h>
+#include <string.h>
+
+/* ---- Schema helpers ---- */
+
+void tf_schema_free(tf_schema *s) {
+    if (!s) return;
+    for (size_t i = 0; i < s->n_cols; i++) {
+        free(s->col_names[i]);
+    }
+    free(s->col_names);
+    free(s->col_types);
+    s->col_names = NULL;
+    s->col_types = NULL;
+    s->n_cols = 0;
+    s->known = false;
+}
+
+void tf_schema_copy(tf_schema *dst, const tf_schema *src) {
+    dst->known = src->known;
+    dst->n_cols = src->n_cols;
+    if (src->n_cols == 0 || !src->known) {
+        dst->col_names = NULL;
+        dst->col_types = NULL;
+        return;
+    }
+    dst->col_names = calloc(src->n_cols, sizeof(char *));
+    dst->col_types = calloc(src->n_cols, sizeof(tf_type));
+    for (size_t i = 0; i < src->n_cols; i++) {
+        dst->col_names[i] = strdup(src->col_names[i]);
+        dst->col_types[i] = src->col_types[i];
+    }
+}
+
+/* ---- IR node helpers ---- */
+
+static void ir_node_clear(tf_ir_node *node) {
+    free((char *)node->op);
+    if (node->args) cJSON_Delete(node->args);
+    tf_schema_free(&node->input_schema);
+    tf_schema_free(&node->output_schema);
+}
+
+/* ---- IR plan API ---- */
+
+tf_ir_plan *tf_ir_plan_create(void) {
+    tf_ir_plan *plan = calloc(1, sizeof(tf_ir_plan));
+    if (!plan) return NULL;
+    plan->capacity = 8;
+    plan->nodes = calloc(plan->capacity, sizeof(tf_ir_node));
+    if (!plan->nodes) { free(plan); return NULL; }
+    return plan;
+}
+
+int tf_ir_plan_add_node(tf_ir_plan *plan, const char *op, cJSON *args) {
+    if (plan->n_nodes >= plan->capacity) {
+        size_t new_cap = plan->capacity * 2;
+        tf_ir_node *new_nodes = realloc(plan->nodes, new_cap * sizeof(tf_ir_node));
+        if (!new_nodes) return -1;
+        memset(new_nodes + plan->capacity, 0,
+               (new_cap - plan->capacity) * sizeof(tf_ir_node));
+        plan->nodes = new_nodes;
+        plan->capacity = new_cap;
+    }
+
+    tf_ir_node *node = &plan->nodes[plan->n_nodes];
+    memset(node, 0, sizeof(tf_ir_node));
+    node->op = strdup(op);
+    node->args = args ? cJSON_Duplicate(args, 1) : cJSON_CreateObject();
+    node->index = plan->n_nodes;
+
+    plan->n_nodes++;
+    plan->validated = false;
+    plan->schema_inferred = false;
+    return 0;
+}
+
+tf_ir_plan *tf_ir_plan_clone(const tf_ir_plan *plan) {
+    tf_ir_plan *clone = tf_ir_plan_create();
+    if (!clone) return NULL;
+
+    for (size_t i = 0; i < plan->n_nodes; i++) {
+        const tf_ir_node *src = &plan->nodes[i];
+        if (tf_ir_plan_add_node(clone, src->op, src->args) != 0) {
+            tf_ir_plan_free(clone);
+            return NULL;
+        }
+        /* Copy schemas if they were inferred */
+        tf_ir_node *dst = &clone->nodes[i];
+        tf_schema_copy(&dst->input_schema, &src->input_schema);
+        tf_schema_copy(&dst->output_schema, &src->output_schema);
+        dst->caps = src->caps;
+    }
+
+    tf_schema_copy(&clone->final_schema, &plan->final_schema);
+    clone->plan_caps = plan->plan_caps;
+    clone->validated = plan->validated;
+    clone->schema_inferred = plan->schema_inferred;
+    if (plan->error) clone->error = strdup(plan->error);
+
+    return clone;
+}
+
+void tf_ir_plan_free(tf_ir_plan *plan) {
+    if (!plan) return;
+    for (size_t i = 0; i < plan->n_nodes; i++) {
+        ir_node_clear(&plan->nodes[i]);
+    }
+    free(plan->nodes);
+    tf_schema_free(&plan->final_schema);
+    free(plan->error);
+    free(plan);
+}

package/csrc/ir.h

@@ -0,0 +1,167 @@
+/*
+ * ir.h — L2 Intermediate Representation types for the Tranfi compilation pipeline.
+ *
+ * Defines the op registry, schema, IR node, and IR plan types.
+ * The IR is the contract between authoring (L3) and execution (L1).
+ */
+
+#ifndef TF_IR_H
+#define TF_IR_H
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+/* Forward declarations */
+typedef struct cJSON cJSON;
+typedef struct tf_ir_node tf_ir_node;
+typedef struct tf_schema tf_schema;
+
+/* ---- Capability flags ---- */
+
+#define TF_CAP_STREAMING      (1 << 0)  /* processes batches without buffering all data */
+#define TF_CAP_BOUNDED_MEMORY (1 << 1)  /* memory usage independent of input size */
+#define TF_CAP_BROWSER_SAFE   (1 << 2)  /* no filesystem/network access */
+#define TF_CAP_DETERMINISTIC  (1 << 3)  /* same input always produces same output */
+#define TF_CAP_FS             (1 << 4)  /* requires filesystem access */
+#define TF_CAP_NET            (1 << 5)  /* requires network access */
+
+/* ---- Op tier ---- */
+
+typedef enum {
+    TF_TIER_CORE,       /* built into the C library */
+    TF_TIER_ECOSYSTEM,  /* provided by host-side plugins */
+} tf_op_tier;
+
+/* ---- Op kind ---- */
+
+typedef enum {
+    TF_OP_DECODER,
+    TF_OP_ENCODER,
+    TF_OP_TRANSFORM,
+} tf_op_kind;
+
+/* ---- Argument descriptor ---- */
+
+typedef struct {
+    const char *name;        /* "delimiter", "expr", "columns", etc. */
+    const char *type;        /* "string", "int", "bool", "string[]", "map" */
+    bool        required;
+    const char *default_val; /* JSON-encoded default, or NULL */
+} tf_arg_desc;
+
+/* ---- Value types (shared with batch system) ---- */
+
+typedef enum tf_type {
+    TF_TYPE_NULL = 0,
+    TF_TYPE_BOOL,
+    TF_TYPE_INT64,
+    TF_TYPE_FLOAT64,
+    TF_TYPE_STRING,
+    TF_TYPE_DATE,       /* int32_t: days since 1970-01-01 */
+    TF_TYPE_TIMESTAMP,  /* int64_t: microseconds since 1970-01-01T00:00:00Z */
+} tf_type;
+
+/* ---- Schema ---- */
+
+struct tf_schema {
+    char    **col_names;
+    tf_type  *col_types;
+    size_t    n_cols;
+    bool      known;  /* false if schema can't be determined until runtime */
+};
+
+void tf_schema_free(tf_schema *s);
+void tf_schema_copy(tf_schema *dst, const tf_schema *src);
+
+/* ---- Op registry entry ---- */
+
+typedef struct {
+    const char    *name;        /* "codec.csv.decode", "filter", etc. */
+    tf_op_kind     kind;
+    tf_op_tier     tier;
+    uint32_t       caps;        /* TF_CAP_* bitfield */
+    tf_arg_desc   *args;
+    size_t         n_args;
+    /* Schema transform: given input schema, compute output schema.
+     * Returns TF_OK or TF_ERROR. */
+    int (*infer_schema)(const tf_ir_node *node,
+                        const tf_schema *in, tf_schema *out);
+    /* Native target constructor (NULL for ecosystem ops).
+     * Returns an opaque pointer (tf_decoder*, tf_step*, or tf_encoder*). */
+    void *(*create_native)(const cJSON *args);
+} tf_op_entry;
+
+/* ---- Op registry API ---- */
+
+const tf_op_entry *tf_op_registry_find(const char *name);
+size_t             tf_op_registry_count(void);
+const tf_op_entry *tf_op_registry_get(size_t index);
+
+/* ---- IR node ---- */
+
+struct tf_ir_node {
+    const char     *op;           /* op name (owned, freed with node) */
+    cJSON          *args;         /* argument values (owned, freed with node) */
+    tf_schema       input_schema;
+    tf_schema       output_schema;
+    uint32_t        caps;         /* resolved capability flags from registry */
+    size_t          index;        /* position in plan */
+};
+
+/* ---- IR plan ---- */
+
+typedef struct tf_ir_plan {
+    tf_ir_node    *nodes;
+    size_t         n_nodes;
+    size_t         capacity;      /* allocated node slots */
+    tf_schema      final_schema;  /* schema after last transform, before encoder */
+    uint32_t       plan_caps;     /* intersection of all node caps */
+    char          *error;         /* validation error, if any */
+    bool           validated;
+    bool           schema_inferred;
+} tf_ir_plan;
+
+/* ---- IR plan API ---- */
+
+tf_ir_plan *tf_ir_plan_create(void);
+int         tf_ir_plan_add_node(tf_ir_plan *plan, const char *op, cJSON *args);
+tf_ir_plan *tf_ir_plan_clone(const tf_ir_plan *plan);
+void        tf_ir_plan_free(tf_ir_plan *plan);
+
+/* ---- IR serialization ---- */
+
+tf_ir_plan *tf_ir_from_json(const char *json, size_t len, char **error);
+char       *tf_ir_to_json(const tf_ir_plan *plan);
+char       *tf_ir_to_sql(const tf_ir_plan *plan, char **error);
+
+/* ---- IR passes ---- */
+
+int tf_ir_validate(tf_ir_plan *plan);
+int tf_ir_infer_schema(tf_ir_plan *plan);
+
+/* ---- Expression eval result ---- */
+
+typedef struct tf_eval_result {
+    tf_type type;
+    union {
+        int64_t     i;     /* INT64 or TIMESTAMP (microseconds since epoch) */
+        double      f;
+        const char *s;
+        bool        b;
+        int32_t     date;  /* DATE: days since epoch */
+    };
+} tf_eval_result;
+
+/* ---- Compiler ---- */
+
+/* Forward declarations of internal types */
+typedef struct tf_decoder tf_decoder;
+typedef struct tf_step tf_step;
+typedef struct tf_encoder tf_encoder;
+
+int tf_compile_native(const tf_ir_plan *plan,
+                      tf_decoder **decoder, tf_step ***steps,
+                      size_t *n_steps, tf_encoder **encoder, char **error);
+
+#endif /* TF_IR_H */

package/csrc/ir_schema.c

@@ -0,0 +1,60 @@
+/*
+ * ir_schema.c — Forward schema inference pass.
+ *
+ * Walks nodes in execution order, calling each op's infer_schema callback
+ * to propagate schema information forward through the plan.
+ * Best-effort and non-fatal — unknown schemas propagate as known=false.
+ */
+
+#include "ir.h"
+#include <stdlib.h>
+
+#define TF_OK    0
+#define TF_ERROR (-1)
+
+int tf_ir_infer_schema(tf_ir_plan *plan) {
+    if (plan->n_nodes == 0) return TF_OK;
+
+    /* Start with an empty, unknown input schema for the first node (decoder) */
+    tf_schema current = {0};
+    current.known = false;
+
+    for (size_t i = 0; i < plan->n_nodes; i++) {
+        tf_ir_node *node = &plan->nodes[i];
+        const tf_op_entry *entry = tf_op_registry_find(node->op);
+
+        /* Copy current schema as this node's input */
+        tf_schema_free(&node->input_schema);
+        tf_schema_copy(&node->input_schema, &current);
+
+        if (entry && entry->infer_schema) {
+            /* Clear old output schema */
+            tf_schema_free(&node->output_schema);
+            entry->infer_schema(node, &current, &node->output_schema);
+
+            /* Advance current to this node's output */
+            tf_schema_free(&current);
+            tf_schema_copy(&current, &node->output_schema);
+        } else {
+            /* No schema inference available — propagate unknown */
+            tf_schema_free(&node->output_schema);
+            node->output_schema.known = false;
+            tf_schema_free(&current);
+            current.known = false;
+        }
+    }
+
+    /* Store final schema (schema before encoder, i.e., last transform's output) */
+    tf_schema_free(&plan->final_schema);
+    if (plan->n_nodes >= 2) {
+        /* The schema before the encoder is the second-to-last node's output */
+        tf_schema_copy(&plan->final_schema,
+                       &plan->nodes[plan->n_nodes - 2].output_schema);
+    } else {
+        plan->final_schema.known = false;
+    }
+
+    tf_schema_free(&current);
+    plan->schema_inferred = true;
+    return TF_OK;
+}