tranfi 0.1.2 → 0.2.1

package/csrc/ir.h

@@ -8,6 +8,7 @@
 #ifndef TF_IR_H
 #define TF_IR_H
 
+#include "config.h"
 #include <stddef.h>
 #include <stdint.h>
 #include <stdbool.h>
@@ -16,6 +17,7 @@
 typedef struct cJSON cJSON;
 typedef struct tf_ir_node tf_ir_node;
 typedef struct tf_schema tf_schema;
+typedef struct tf_host_policy tf_host_policy;
 
 /* ---- Capability flags ---- */
 
@@ -41,6 +43,29 @@ typedef enum {
     TF_OP_TRANSFORM,
 } tf_op_kind;
 
+/* ---- Streaming contract metadata ---- */
+
+typedef enum {
+    TF_MEM_ROW_LOCAL,       /* O(batch_rows * columns) */
+    TF_MEM_BOUNDED_STATE,   /* O(parameter), e.g. window K or tail N */
+    TF_MEM_KEY_STATE,       /* O(distinct keys/categories) */
+    TF_MEM_BLOCKING,        /* needs full input in native mode */
+    TF_MEM_EXTERNAL,        /* uses spill/SQL/external bounded storage */
+} tf_memory_class;
+
+typedef enum {
+    TF_EMIT_PER_BATCH,      /* can emit during push() */
+    TF_EMIT_ON_FLUSH,       /* emits only at finish(), e.g. tail/top/stats */
+    TF_EMIT_SIDE_ONLY,      /* writes side channels, not main output */
+    TF_EMIT_MIXED,          /* emits both during push() and flush/side output */
+} tf_emit_class;
+
+typedef enum {
+    TF_SCHEMA_STABLE,       /* output columns known from input schema/args */
+    TF_SCHEMA_PARAMETRIC,   /* output schema depends on explicit parameters */
+    TF_SCHEMA_DATA_DEPENDENT, /* output schema depends on observed data */
+} tf_schema_class;
+
 /* ---- Argument descriptor ---- */
 
 typedef struct {
@@ -52,6 +77,8 @@ typedef struct {
 
 /* ---- Value types (shared with batch system) ---- */
 
+#ifndef TF_TYPE_DEFINED
+#define TF_TYPE_DEFINED
 typedef enum tf_type {
     TF_TYPE_NULL = 0,
     TF_TYPE_BOOL,
@@ -61,6 +88,7 @@ typedef enum tf_type {
     TF_TYPE_DATE,       /* int32_t: days since 1970-01-01 */
     TF_TYPE_TIMESTAMP,  /* int64_t: microseconds since 1970-01-01T00:00:00Z */
 } tf_type;
+#endif
 
 /* ---- Schema ---- */
 
@@ -73,6 +101,7 @@ struct tf_schema {
 
 void tf_schema_free(tf_schema *s);
 void tf_schema_copy(tf_schema *dst, const tf_schema *src);
+int  tf_schema_copy_checked(tf_schema *dst, const tf_schema *src);
 
 /* ---- Op registry entry ---- */
 
@@ -81,6 +110,10 @@ typedef struct {
     tf_op_kind     kind;
     tf_op_tier     tier;
     uint32_t       caps;        /* TF_CAP_* bitfield */
+    tf_memory_class memory_class;
+    tf_emit_class   emit_class;
+    tf_schema_class schema_class;
+    const char    *state_estimate; /* Big-O state retained by the op */
     tf_arg_desc   *args;
     size_t         n_args;
     /* Schema transform: given input schema, compute output schema.
@@ -97,6 +130,9 @@ typedef struct {
 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);
+const char        *tf_memory_class_name(tf_memory_class cls);
+const char        *tf_emit_class_name(tf_emit_class cls);
+const char        *tf_schema_class_name(tf_schema_class cls);
 
 /* ---- IR node ---- */
 
@@ -106,6 +142,10 @@ struct tf_ir_node {
     tf_schema       input_schema;
     tf_schema       output_schema;
     uint32_t        caps;         /* resolved capability flags from registry */
+    tf_memory_class memory_class;
+    tf_emit_class   emit_class;
+    tf_schema_class schema_class;
+    const char     *state_estimate; /* Big-O state estimate, static string */
     size_t          index;        /* position in plan */
 };
 
@@ -138,6 +178,7 @@ 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_validate_with_host_policy(tf_ir_plan *plan, const tf_host_policy *policy);
 int tf_ir_infer_schema(tf_ir_plan *plan);
 
 /* ---- Expression eval result ---- */

package/csrc/ir_schema.c

@@ -25,16 +25,27 @@ int tf_ir_infer_schema(tf_ir_plan *plan) {
 
         /* Copy current schema as this node's input */
         tf_schema_free(&node->input_schema);
-        tf_schema_copy(&node->input_schema, &current);
+        if (tf_schema_copy_checked(&node->input_schema, &current) != TF_OK) {
+            tf_schema_free(&current);
+            plan->schema_inferred = false;
+            return TF_ERROR;
+        }
 
         if (entry && entry->infer_schema) {
             /* Clear old output schema */
             tf_schema_free(&node->output_schema);
-            entry->infer_schema(node, &current, &node->output_schema);
+            if (entry->infer_schema(node, &current, &node->output_schema) != TF_OK) {
+                tf_schema_free(&current);
+                plan->schema_inferred = false;
+                return TF_ERROR;
+            }
 
             /* Advance current to this node's output */
             tf_schema_free(&current);
-            tf_schema_copy(&current, &node->output_schema);
+            if (tf_schema_copy_checked(&current, &node->output_schema) != TF_OK) {
+                plan->schema_inferred = false;
+                return TF_ERROR;
+            }
         } else {
             /* No schema inference available — propagate unknown */
             tf_schema_free(&node->output_schema);
@@ -48,8 +59,12 @@ int tf_ir_infer_schema(tf_ir_plan *plan) {
     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);
+        if (tf_schema_copy_checked(&plan->final_schema,
+                                   &plan->nodes[plan->n_nodes - 2].output_schema) != TF_OK) {
+            tf_schema_free(&current);
+            plan->schema_inferred = false;
+            return TF_ERROR;
+        }
     } else {
         plan->final_schema.known = false;
     }

package/csrc/ir_serialize.c

@@ -11,7 +11,7 @@
  * }
  */
 
-#include "ir.h"
+#include "internal.h"
 #include "cJSON.h"
 #include <stdlib.h>
 #include <string.h>
@@ -84,18 +84,80 @@ 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) {
     cJSON *root = cJSON_CreateObject();
-    cJSON *steps = cJSON_AddArrayToObject(root, "steps");
+    if (!root) return NULL;
+    cJSON *steps = cJSON_CreateArray();
+    if (!steps || tf_json_add_item(root, "steps", steps) != TF_OK) {
+        cJSON_Delete(root);
+        return NULL;
+    }
 
     for (size_t i = 0; i < plan->n_nodes; i++) {
         const tf_ir_node *node = &plan->nodes[i];
         cJSON *step = cJSON_CreateObject();
-        cJSON_AddStringToObject(step, "op", node->op);
+        if (!step) {
+            cJSON_Delete(root);
+            return NULL;
+        }
+        if (tf_json_add_string(step, "op", node->op) != TF_OK) {
+            cJSON_Delete(step);
+            cJSON_Delete(root);
+            return NULL;
+        }
         if (node->args) {
-            cJSON_AddItemToObject(step, "args", cJSON_Duplicate(node->args, 1));
+            cJSON *args = cJSON_Duplicate(node->args, 1);
+            if (args) {
+                cJSON_DeleteItemFromObjectCaseSensitive(args, TF_POLICY_VALIDATED_FILE_PATH_ARG);
+                cJSON_DeleteItemFromObjectCaseSensitive(args, TF_POLICY_VALIDATED_RULES_FILE_PATH_ARG);
+            }
+            if (!args || tf_json_add_item(step, "args", args) != TF_OK) {
+                cJSON_Delete(step);
+                cJSON_Delete(root);
+                return NULL;
+            }
         } else {
-            cJSON_AddItemToObject(step, "args", cJSON_CreateObject());
+            cJSON *args = cJSON_CreateObject();
+            if (!args || tf_json_add_item(step, "args", args) != TF_OK) {
+                cJSON_Delete(step);
+                cJSON_Delete(root);
+                return NULL;
+            }
+        }
+        if (tf_json_add_string(step, "memory_class", tf_memory_class_name(node->memory_class)) != TF_OK ||
+            tf_json_add_string(step, "emit_class", tf_emit_class_name(node->emit_class)) != TF_OK ||
+            tf_json_add_string(step, "schema_class", tf_schema_class_name(node->schema_class)) != TF_OK ||
+            tf_json_add_string(step, "state_estimate",
+                               node->state_estimate ? node->state_estimate : "unknown") != TF_OK) {
+            cJSON_Delete(step);
+            cJSON_Delete(root);
+            return NULL;
+        }
+        size_t state_bytes = 0;
+        char state_reason[192] = {0};
+        if (tf_estimate_step_state_bytes(node, &state_bytes, state_reason, sizeof(state_reason))) {
+            if (tf_json_add_number(step, "state_bytes_estimate", (double)state_bytes) != TF_OK) {
+                cJSON_Delete(step);
+                cJSON_Delete(root);
+                return NULL;
+            }
+        } else {
+            if (tf_json_add_null(step, "state_bytes_estimate") != TF_OK) {
+                cJSON_Delete(step);
+                cJSON_Delete(root);
+                return NULL;
+            }
+            if (node->memory_class == TF_MEM_KEY_STATE || node->memory_class == TF_MEM_BLOCKING) {
+                if (tf_json_add_string(step, "state_bytes_reason",
+                                       state_reason[0] ? state_reason : "no native byte estimator") != TF_OK) {
+                    cJSON_Delete(step);
+                    cJSON_Delete(root);
+                    return NULL;
+                }
+            }
+        }
+        if (tf_json_add_array_item(steps, step) != TF_OK) {
+            cJSON_Delete(root);
+            return NULL;
         }
-        cJSON_AddItemToArray(steps, step);
     }
 
     char *out = cJSON_PrintUnformatted(root);