teptris 0.2.42-arm-linux → 0.2.48-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 408acdf7a018bcbcda74930c9dd3caa40d1eecab0649648e3cfa99991bf582e7
-  data.tar.gz: 0214f7776574f00024d8a86decc9298a5837b9339b42e5808b6565821d879491
+  metadata.gz: 37c4b4597737ec0da5db36671c56a9d8f8654de5fae121cc460032a6c9ddad40
+  data.tar.gz: 02e41f249fde41675bcf6d67103dfde81573957a4166961678cee168f39f0fa3
 SHA512:
-  metadata.gz: 81a5e7acbf7eb28ab7359878c6924ac9a9faae9433b6ec6a883e0d7169102504bf590dbbb561dcc5913315e4a35f0db523d3084e1d8ff10428989b5d43cecf97
-  data.tar.gz: c72ea61233472cd443ddaf2da90aa18f2e2e014aefbeffc879f9c570b68b56a12720624e663a99a9f2e3e92618f84991a09457fd1bf9f321cf8e4fc36d22dcb0
+  metadata.gz: 3c21eed21fd021093018a1d6d1cb42d8483b5c31a9d9a3fa4cd02ddcc4f579f56060471437b9cf87f14498a3128b433d54de646b19cb447d30adaf31f196161b
+  data.tar.gz: 4849d8e86c3a4a057b871e55f45cd08ab83bada7c85e6367016d685121627bba3c7e6090e38bfc755f5a4e3b23dbfa49670e17add5b02c395d1ea30c7cd1aa03

data/ext/teptris_ext/engine/README.md

@@ -1,4 +1,4 @@
-# libteptris 0.1.24 — vendored source
+# libteptris 0.1.27 — vendored source
 
 This directory carries the COMPLETE C source of the engine this
 gem's extension was built from (the packaging doctrine: compiled

data/ext/teptris_ext/engine/src/include/teptris/teptris.h

@@ -91,6 +91,19 @@ TEPTRIS_API teptris_status teptris_parse(const char *data, size_t len,
                              const teptris_options *opts,
                              teptris_document **out);
 
+/* Parse N TOML documents in a single call. Caller pre-allocates
+ * `out_docs[N]` and `out_statuses[N]` and frees each doc with
+ * teptris_document_free. Per-document parse failures are reported
+ * through out_statuses[i] (out_docs[i] is set so the caller can read
+ * the error via teptris_document_error and free). TEPTRIS_ERR_ALLOC
+ * means no documents were created — caller must not free. The `opts`
+ * pointer is shared across the batch. n == 0 is TEPTRIS_OK and a
+ * no-op. */
+TEPTRIS_API teptris_status teptris_parse_batch(
+    const char *const *data, const size_t *lens, size_t n,
+    const teptris_options *opts,
+    teptris_document **out_docs, teptris_status *out_statuses);
+
 /* Memory: frees every allocation reachable from the document. */
 TEPTRIS_API void teptris_document_free(teptris_document *doc);
 

data/ext/teptris_ext/engine/src/include/teptris/version.h

@@ -3,7 +3,7 @@
 
 #define TEPTRIS_VERSION_MAJOR 0
 #define TEPTRIS_VERSION_MINOR 1
-#define TEPTRIS_VERSION_PATCH 24
-#define TEPTRIS_VERSION_STRING "0.1.24"
+#define TEPTRIS_VERSION_PATCH 27
+#define TEPTRIS_VERSION_STRING "0.1.27"
 
 #endif /* TEPTRIS_VERSION_H */

data/ext/teptris_ext/engine/src/teptris/api.c

@@ -34,6 +34,59 @@ teptris_status teptris_parse(const char *data, size_t len,
     return st;
 }
 
+teptris_status teptris_parse_batch(const char *const *data, const size_t *lens,
+                                   size_t n, const teptris_options *opts,
+                                   teptris_document **out_docs,
+                                   teptris_status *out_statuses)
+{
+    if (n == 0) {
+        return TEPTRIS_OK;
+    }
+    if (data == NULL || lens == NULL || out_docs == NULL ||
+        out_statuses == NULL) {
+        return TEPTRIS_ERR_ARG;
+    }
+    /* Zero the per-doc outputs up front: on the alloc-fail path every
+     * entry must look like "no doc to free" so callers don't double-free
+     * a partial batch. */
+    for (size_t i = 0; i < n; i++) {
+        out_docs[i] = NULL;
+        out_statuses[i] = TEPTRIS_OK;
+    }
+    uint32_t max_depth =
+        (opts != NULL && opts->max_depth != 0) ? opts->max_depth : 512;
+    for (size_t i = 0; i < n; i++) {
+        teptris_document *doc = calloc(1, sizeof(teptris_document));
+        if (doc == NULL) {
+            /* Free any documents we already created; statuses for the
+             * failed slot onward were zero-initialized, so out_statuses
+             * stays consistent. */
+            for (size_t j = 0; j < i; j++) {
+                teptris_arena_destroy(&out_docs[j]->arena);
+                free(out_docs[j]);
+                out_docs[j] = NULL;
+            }
+            return TEPTRIS_ERR_ALLOC;
+        }
+        teptris_arena_init(&doc->arena);
+        doc->max_depth = max_depth;
+        doc->err.status = TEPTRIS_OK;
+        doc->err.message = "";
+        teptris_status st = teptris_parser_run(doc, data[i], lens[i]);
+        if (st != TEPTRIS_OK && doc->err.status == TEPTRIS_OK) {
+            doc->err.status = st;
+            if (st == TEPTRIS_ERR_ALLOC) {
+                snprintf(doc->err_msg, sizeof(doc->err_msg),
+                         "out of memory");
+            }
+            doc->err.message = doc->err_msg;
+        }
+        out_docs[i] = doc;
+        out_statuses[i] = st;
+    }
+    return TEPTRIS_OK;
+}
+
 void teptris_document_free(teptris_document *doc)
 {
     if (doc == NULL) {

data/ext/teptris_ext/materialize.c

@@ -21,18 +21,25 @@ static int64_t days_from_civil(int32_t y, uint8_t m, uint8_t d) {
 }
 
 /* exact (no double) Time materialization: nsec stays nsec. Offset
- * datetimes go through timespec+fixed-offset; local datetimes through
- * Time.local with Rational seconds (rb_time_timespec_new's INT_MAX
- * treats the timespec as an absolute instant, not wall-clock local). */
+ * datetimes carry a fixed utc offset via rb_time_num_new; local
+ * datetimes go through Time.local with Rational seconds (both treat
+ * the epoch value as wall-clock for locals / instant+offset for
+ * fixed zones). No struct timespec crosses the Ruby boundary:
+ * armhf glibc rubies build with _TIME_BITS=64 (16-byte timespec)
+ * while an ext compiled without it lays out 8 bytes — the struct
+ * APIs then read (load) or write (dump) past each side's layout. */
 static VALUE time_from_dt(const teptris_datetime *d, bool has_offset) {
     if (has_offset) {
         int64_t days = days_from_civil(d->year, d->month, d->day);
         int64_t secs =
             days * 86400 + d->hour * 3600 + d->minute * 60 + d->second;
-        struct timespec ts;
-        ts.tv_sec = (time_t)(secs - d->offset_seconds);
-        ts.tv_nsec = (long)d->nanosecond;
-        return rb_time_timespec_new(&ts, d->offset_seconds);
+        VALUE num = LL2NUM(secs - d->offset_seconds);
+        if (d->nanosecond != 0) {
+            num = rb_funcall(num, '+', 1,
+                             rb_Rational(LL2NUM((int64_t)d->nanosecond),
+                                         LL2NUM(1000000000)));
+        }
+        return rb_time_num_new(num, INT2FIX(d->offset_seconds));
     }
     VALUE args[6] = {INT2FIX(d->year), INT2FIX(d->month), INT2FIX(d->day),
                      INT2FIX(d->hour), INT2FIX(d->minute),
@@ -51,7 +58,19 @@ static VALUE dt_string(const teptris_datetime *d, int kind) {
         const char *head = (kind == TEPTRIS_TIME_LOCAL) ? "" : "";
         (void)head;
         if (kind == TEPTRIS_TIME_LOCAL) {
-            l = snprintf(buf, sizeof buf, "%02u:%02u:%02u", d->hour, d->minute, d->second);
+            /* tomlib's contract keeps the fraction at millisecond
+             * precision (00:32:00.999); drop it entirely when zero.
+             * The engine preserves full nanoseconds — the binding
+             * truncates to the reference shape. */
+            if (d->nanosecond != 0) {
+                unsigned ms = (d->nanosecond + 500000u) / 1000000u;
+                if (ms == 1000u) ms = 999u; /* rounding overflow guard */
+                l = snprintf(buf, sizeof buf, "%02u:%02u:%02u.%03u",
+                             d->hour, d->minute, d->second, ms);
+            } else {
+                l = snprintf(buf, sizeof buf, "%02u:%02u:%02u",
+                             d->hour, d->minute, d->second);
+            }
         } else {
             l = snprintf(buf, sizeof buf, "%04d-%02u-%02uT%02u:%02u:%02u",
                          d->year, d->month, d->day, d->hour, d->minute, d->second);
@@ -70,7 +89,87 @@ static VALUE dt_string(const teptris_datetime *d, int kind) {
     return rb_enc_str_new(buf, l, rb_utf8_encoding());
 }
 
-static VALUE obj_from_node(const teptris_node *n, unsigned flags) {
+/* ---- per-load table-key cache ------------------------------------------------
+ * TOML keys repeat within a document and across a batch; a fresh String
+ * per occurrence costs an allocation and a full Hash re-hash each time.
+ * This cache maps key CONTENT to one frozen String, shared everywhere:
+ * repeated keys become a single GC-pinned object with its hash already
+ * computed. It is document-local (dies with the load call), capped at
+ * KC_CAP entries so unique-key corpora pay only a cheap failed probe
+ * after the cap, and never touches the VM's global fstring table (the
+ * intern-always attempt regressed there — teptris-ruby#122: unique
+ * keys make the intern table pure overhead). Strings are frozen so the
+ * sharing cannot alias a mutation. NULL cache = fresh strings (the
+ * low-volume schema-RAW path). */
+
+#define KC_CAP 4096
+#define KC_SLOTS (KC_CAP * 2) /* stays <=50% full: probes stay ~2 */
+
+typedef struct {
+    VALUE str; /* Qfalse = empty slot */
+} kc_slot;
+
+typedef struct {
+    VALUE keep; /* Ruby Array pinning every cached String */
+    kc_slot *slots;
+    size_t used;
+} keycache;
+
+static uint64_t kc_hash(const char *p, size_t len)
+{
+    uint64_t h = 1469598103934665603ULL;
+    for (size_t i = 0; i < len; i++) {
+        h ^= (unsigned char)p[i];
+        h *= 1099511628211ULL;
+    }
+    return h;
+}
+
+static void kc_init(keycache *kc)
+{
+    kc->keep = rb_ary_new_capa(64);
+    kc->slots = calloc(KC_SLOTS, sizeof(kc_slot)); /* zero = Qfalse empty */
+    if (kc->slots == NULL) {
+        /* no cache is a correctness-preserving fallback */
+        kc->keep = Qnil;
+        return;
+    }
+    kc->used = 0;
+}
+
+static void kc_free(keycache *kc)
+{
+    free(kc->slots);
+    kc->slots = NULL;
+}
+
+static VALUE kc_key(keycache *kc, const char *p, size_t len)
+{
+    if (kc == NULL || kc->slots == NULL) {
+        return rb_enc_str_new(p, (long)len, rb_utf8_encoding());
+    }
+    size_t mask = KC_SLOTS - 1;
+    size_t slot = (size_t)kc_hash(p, len) & mask;
+    while (kc->slots[slot].str != Qfalse) {
+        VALUE s = kc->slots[slot].str;
+        if ((size_t)RSTRING_LEN(s) == len &&
+            memcmp(RSTRING_PTR(s), p, len) == 0) {
+            return s; /* hit: one shared object, hash already cached */
+        }
+        slot = (slot + 1) & mask;
+    }
+    VALUE fresh = rb_enc_str_new(p, (long)len, rb_utf8_encoding());
+    rb_obj_freeze(fresh);
+    rb_ary_push(kc->keep, fresh); /* GC pin before it enters the slots */
+    if (kc->used < KC_CAP) {
+        kc->slots[slot].str = fresh;
+        kc->used++;
+    }
+    return fresh;
+}
+
+static VALUE obj_from_node(const teptris_node *n, unsigned flags,
+                           keycache *kc) {
     switch (teptris_node_kind(n)) {
     case TEPTRIS_TABLE: {
         size_t len = teptris_node_table_length(n);
@@ -78,9 +177,8 @@ static VALUE obj_from_node(const teptris_node *n, unsigned flags) {
         for (size_t i = 0; i < len; i++) {
             teptris_view key;
             const teptris_node *v = teptris_node_table_at(n, i, &key);
-            rb_hash_aset(h,
-                rb_enc_str_new(key.ptr, (long)key.len, rb_utf8_encoding()),
-                obj_from_node(v, flags));
+            rb_hash_aset(h, kc_key(kc, key.ptr, (size_t)key.len),
+                         obj_from_node(v, flags, kc));
         }
         return h;
     }
@@ -88,7 +186,7 @@ static VALUE obj_from_node(const teptris_node *n, unsigned flags) {
         size_t len = teptris_node_array_length(n);
         VALUE a = rb_ary_new_capa((long)len);
         for (size_t i = 0; i < len; i++)
-            rb_ary_push(a, obj_from_node(teptris_node_array_at(n, i), flags));
+            rb_ary_push(a, obj_from_node(teptris_node_array_at(n, i), flags, kc));
         return a;
     }
     case TEPTRIS_STRING: {
@@ -157,7 +255,10 @@ static VALUE ext_load(int argc, VALUE *argv, VALUE self) {
         if (RTEST(fd)) flags |= FMT_FORBID_DATE;
     }
     teptris_document *doc = parse_or_raise(str);
-    VALUE out = obj_from_node(teptris_document_root(doc), flags);
+    keycache kc;
+    kc_init(&kc);
+    VALUE out = obj_from_node(teptris_document_root(doc), flags, &kc);
+    kc_free(&kc);
     teptris_document_free(doc);
     return out;
 }
@@ -168,7 +269,7 @@ static VALUE ext_version(VALUE self) {
 
 /* ------------------------------------------------------------------ dump */
 
-static ID id_utc_offset, id_to_s;
+static ID id_utc_offset, id_to_s, id_to_i, id_nsec;
 
 static void dump_check(teptris_status st) {
     if (st == TEPTRIS_OK) return;
@@ -194,12 +295,12 @@ static void civil_from_days(int64_t z, int32_t *y, uint8_t *m, uint8_t *d) {
     *d = (uint8_t)dd;
 }
 
-/* two crossings per Time: timespec + utc_offset; the civil fields come
- * from integer math (epoch + offset -> y/m/d h:m:s + tv_nsec) */
+/* the instant and its subsecond part come back as Integers (to_i
+ * floors, nsec stays in [0, 1e9) — same split the timespec gave);
+ * the civil fields are integer math on epoch + offset */
 static void fill_dt_from_time(VALUE v, teptris_datetime *dt) {
-    struct timespec ts = rb_time_timespec(v);
     dt->offset_seconds = NUM2INT(rb_funcall(v, id_utc_offset, 0));
-    int64_t secs = (int64_t)ts.tv_sec + dt->offset_seconds;
+    int64_t secs = NUM2LL(rb_funcall(v, id_to_i, 0)) + dt->offset_seconds;
     int64_t days = secs / 86400;
     int32_t rem = (int32_t)(secs % 86400);
     if (rem < 0) { /* floor division: keep rem in [0, 86400) */
@@ -210,7 +311,7 @@ static void fill_dt_from_time(VALUE v, teptris_datetime *dt) {
     dt->hour = (uint8_t)(rem / 3600);
     dt->minute = (uint8_t)((rem / 60) % 60);
     dt->second = (uint8_t)(rem % 60);
-    dt->nanosecond = (uint32_t)ts.tv_nsec;
+    dt->nanosecond = (uint32_t)NUM2LL(rb_funcall(v, id_nsec, 0));
 }
 
 static void dump_scalar(teptris_builder *b, const char *key, size_t klen,
@@ -507,7 +608,7 @@ static VALUE asm_rows(const teptris_plan *p, const teptris_plan_result *res,
         case TEPTRIS_PLAN_RAW_RESULT: {
             const teptris_node *raw = teptris_plan_result_raw_at(res, i);
             if (raw != NULL) {
-                val = obj_from_node(raw, 0);
+                val = obj_from_node(raw, 0, NULL);
             }
             break;
         }
@@ -590,9 +691,366 @@ static VALUE ext_plan_emit(VALUE self, VALUE rb_plan, VALUE toml)
     return out;
 }
 
+
+/* ---- lazy mode (#79) ----------------------------------------------
+ * load_lazy returns a LazyValue wrapping the parsed tree: scalar
+ * access materializes scalars only, tables/arrays stay wrapped until
+ * walked. The document and the borrowed-input String live in a
+ * single owner object every wrapper references, so GC lifetime is
+ * one edge deep. Free order is GC-driven via TypedData dfree. */
+
+static VALUE cLazyOwner, cLazyValue;
+
+typedef struct {
+    teptris_document *doc;
+    VALUE input; /* the borrowed views' buffer */
+} lazy_owner;
+
+typedef struct {
+    VALUE owner; /* LazyOwner: keeps doc + input alive */
+    const teptris_node *node;
+} lazy_value;
+
+static void lazy_owner_free(void *p) {
+    lazy_owner *o = (lazy_owner *)p;
+    if (o->doc != NULL) teptris_document_free(o->doc);
+    xfree(o);
+}
+static size_t lazy_owner_size(const void *p) { return sizeof(lazy_owner); }
+static const rb_data_type_t lazy_owner_type = {
+    "TeptrisExt/LazyOwner",
+    {NULL, lazy_owner_free, lazy_owner_size, NULL, 0},
+    NULL, NULL, RUBY_TYPED_FREE_IMMEDIATELY};
+
+static void lazy_value_mark(void *p) {
+    lazy_value *v = (lazy_value *)p;
+    rb_gc_mark(v->owner);
+}
+static void lazy_value_free(void *p) { xfree(p); }
+static size_t lazy_value_size(const void *p) { return sizeof(lazy_value); }
+static const rb_data_type_t lazy_value_type = {
+    "TeptrisExt/LazyValue",
+    {lazy_value_mark, lazy_value_free, lazy_value_size, NULL, 0},
+    NULL, NULL, RUBY_TYPED_FREE_IMMEDIATELY};
+
+static VALUE lazy_wrap(VALUE owner, const teptris_node *n) {
+    lazy_value *v;
+    VALUE obj = TypedData_Make_Struct(cLazyValue, lazy_value,
+                                      &lazy_value_type, v);
+    v->owner = owner;
+    v->node = n;
+    return obj;
+}
+
+static lazy_value *lazy_self(VALUE self) {
+    lazy_value *v;
+    TypedData_Get_Struct(self, lazy_value, &lazy_value_type, v);
+    return v;
+}
+
+static VALUE ext_load_lazy(VALUE self, VALUE toml) {
+    StringValue(toml);
+    lazy_owner *o;
+    VALUE owner = TypedData_Make_Struct(cLazyOwner, lazy_owner,
+                                        &lazy_owner_type, o);
+    o->doc = NULL;
+    o->input = rb_str_new_frozen(toml); /* borrowed views: own a copy */
+    teptris_status st = teptris_parse(RSTRING_PTR(o->input),
+                                      (size_t)RSTRING_LEN(o->input),
+                                      NULL, &o->doc);
+    if (st != TEPTRIS_OK) {
+        const teptris_error *e = teptris_document_error(o->doc);
+        VALUE ex = rb_exc_new(eParseError, e->message,
+                              (long)strlen(e->message));
+        rb_iv_set(ex, "@line", SIZET2NUM(e->line));
+        rb_iv_set(ex, "@column", SIZET2NUM(e->column));
+        rb_exc_raise(ex); /* owner GC-frees the failed doc */
+    }
+    return lazy_wrap(owner, teptris_document_root(o->doc));
+}
+
+static VALUE lazy_kind(VALUE self) {
+    switch (teptris_node_kind(lazy_self(self)->node)) {
+    case TEPTRIS_TABLE: return ID2SYM(rb_intern("table"));
+    case TEPTRIS_ARRAY: return ID2SYM(rb_intern("array"));
+    default: return ID2SYM(rb_intern("scalar"));
+    }
+}
+
+static VALUE lazy_size(VALUE self) {
+    const teptris_node *n = lazy_self(self)->node;
+    switch (teptris_node_kind(n)) {
+    case TEPTRIS_TABLE: return SIZET2NUM(teptris_node_table_length(n));
+    case TEPTRIS_ARRAY: return SIZET2NUM(teptris_node_array_length(n));
+    default: return Qnil;
+    }
+}
+
+/* table: iterate entries; array: iterate items; scalar: raise */
+static VALUE lazy_each(VALUE self) {
+    RETURN_SIZED_ENUMERATOR(self, 0, 0, 0);
+    const teptris_node *n = lazy_self(self)->node;
+    switch (teptris_node_kind(n)) {
+    case TEPTRIS_TABLE: {
+        size_t len = teptris_node_table_length(n);
+        for (size_t i = 0; i < len; i++) {
+            teptris_view key;
+            const teptris_node *v = teptris_node_table_at(n, i, &key);
+            VALUE kv = rb_ary_new_capa(2);
+            rb_ary_push(kv, rb_enc_str_new(key.ptr, (long)key.len,
+                                           rb_utf8_encoding()));
+            rb_ary_push(kv, lazy_wrap(lazy_self(self)->owner, v));
+            rb_yield(kv);
+        }
+        break;
+    }
+    case TEPTRIS_ARRAY: {
+        size_t len = teptris_node_array_length(n);
+        for (size_t i = 0; i < len; i++)
+            rb_yield(lazy_wrap(lazy_self(self)->owner,
+                               teptris_node_array_at(n, i)));
+        break;
+    }
+    default:
+        rb_raise(eError, "scalar node has nothing to iterate");
+    }
+    return self;
+}
+
+/* [] is polymorphic by node kind: tables take string keys (hash
+ * index), arrays take integer indices (contiguous array) - both O(1)
+ * per access, which is the whole point of the lazy mode */
+static VALUE lazy_get(VALUE self, VALUE key) {
+    lazy_value *v = lazy_self(self);
+    const teptris_node *child = NULL;
+    switch (teptris_node_kind(v->node)) {
+    case TEPTRIS_TABLE: {
+        const char *k;
+        long kl;
+        if (RB_TYPE_P(key, T_STRING)) {
+            k = RSTRING_PTR(key); kl = RSTRING_LEN(key);
+        } else {
+            key = rb_funcall(key, rb_intern("to_s"), 0);
+            k = RSTRING_PTR(key); kl = RSTRING_LEN(key);
+        }
+        child = teptris_node_table_get(v->node, k, (size_t)kl);
+        break;
+    }
+    case TEPTRIS_ARRAY: {
+        long i = NUM2LONG(key);
+        if (i < 0) i += (long)teptris_node_array_length(v->node);
+        child = teptris_node_array_at(v->node, (size_t)i);
+        break;
+    }
+    default:
+        rb_raise(eError, "scalar node is not subscriptable");
+    }
+    if (child == NULL) return Qnil;
+    return lazy_wrap(v->owner, child);
+}
+
+static VALUE lazy_dig(int argc, VALUE *argv, VALUE self) {
+    VALUE cur = self;
+    for (long i = 0; i < argc; i++) {
+        VALUE nxt = rb_funcall(cur, rb_intern("[]"), 1, argv[i]);
+        if (nxt == Qnil || nxt == Qundef) return Qnil;
+        cur = nxt;
+    }
+    return cur;
+}
+
+/* full materialization: the eager path, owned */
+static VALUE lazy_to(VALUE self) {
+    lazy_value *v = lazy_self(self);
+    keycache kc;
+    kc_init(&kc);
+    VALUE out = obj_from_node(v->node, 0, &kc);
+    kc_free(&kc);
+    return out;
+}
+
+/* ---------------------------------------------------------------- batch --
+ * Many-small batch path (teptris-ruby#108 ask 3, complements the C
+ * `teptris_parse_batch`): accept an Array of TOML strings + an options
+ * hash, parse every entry in one C call (one opts struct, one
+ * per-doc-status report), and return one Ruby Hash per document. The
+ * options bag is parsed ONCE and shared across the batch — per-doc
+ * safe_load/datetime_policy work happens in C, not in N Ruby frames.
+ * On the alloc-fail path the C call leaves no partial docs; the Ruby
+ * caller sees a Teptris::Error. Per-doc parse failures are collected
+ * alongside the successes in a parallel array (the lazy variant
+ * raises on the first failure so callers can `rescue` without losing
+ * the partial batch). */
+
+/* Combined scratch layout — one alloc, four arrays packed end-to-end.
+ * Splitting into four mallocs showed up as the dominant cost in the
+ * per-doc benchmark for tiny docs (4× malloc/free per call, 16–64 KB
+ * of scratch per call). One alloc amortizes the heap and the cache. */
+typedef struct {
+    const char **data;
+    size_t *lens;
+    teptris_document **docs;
+    teptris_status *statuses;
+} batch_scratch;
+
+static void batch_scratch_free(batch_scratch *s) {
+    free(s->data);
+    free(s);
+}
+
+static batch_scratch *batch_scratch_alloc(long n) {
+    batch_scratch *s = (batch_scratch *)malloc(sizeof(*s));
+    if (s == NULL) return NULL;
+    size_t bytes =
+        (size_t)n * (sizeof(const char *) + sizeof(size_t) +
+                     sizeof(teptris_document *) + sizeof(teptris_status));
+    void *blob = malloc(bytes);
+    if (blob == NULL) {
+        free(s);
+        return NULL;
+    }
+    char *p = (char *)blob;
+    s->data = (const char **)p;
+    p += (size_t)n * sizeof(const char *);
+    s->lens = (size_t *)p;
+    p += (size_t)n * sizeof(size_t);
+    s->docs = (teptris_document **)p;
+    p += (size_t)n * sizeof(teptris_document *);
+    s->statuses = (teptris_status *)p;
+    return s;
+}
+
+static unsigned flags_from_opts(VALUE opts) {
+    unsigned flags = 0;
+    if (NIL_P(opts)) return 0;
+    VALUE sd = rb_hash_aref(opts, ID2SYM(rb_intern("string_datetimes")));
+    VALUE ft = rb_hash_aref(opts, ID2SYM(rb_intern("forbid_time")));
+    VALUE fd = rb_hash_aref(opts, ID2SYM(rb_intern("forbid_date")));
+    if (RTEST(sd)) flags |= FMT_STRING_DATES;
+    if (RTEST(ft)) flags |= FMT_FORBID_TIME;
+    if (RTEST(fd)) flags |= FMT_FORBID_DATE;
+    return flags;
+}
+
+/* Parse-only batch (returns an Array of Lazy wrappers, one per doc):
+ * eager parse, deferred materialization. Same per-doc error semantics
+ * as ext_load_lazy. */
+static VALUE ext_load_lazy_batch(VALUE self, VALUE strings) {
+    Check_Type(strings, T_ARRAY);
+    long n = RARRAY_LEN(strings);
+    if (n == 0) return rb_ary_new();
+    batch_scratch *s = batch_scratch_alloc(n);
+    if (s == NULL) rb_raise(eError, "out of memory batching %ld documents", n);
+    for (long i = 0; i < n; i++) {
+        VALUE str = rb_ary_entry(strings, i);
+        StringValue(str); /* raises TypeError if not coercible */
+        s->data[i] = RSTRING_PTR(str);
+        s->lens[i] = (size_t)RSTRING_LEN(str);
+    }
+    teptris_status batch =
+        teptris_parse_batch(s->data, s->lens, (size_t)n, NULL,
+                            s->docs, s->statuses);
+    if (batch != TEPTRIS_OK) {
+        batch_scratch_free(s);
+        rb_raise(eError, "batch parse failed (status %d)", (int)batch);
+    }
+    long first_fail = -1;
+    for (long i = 0; i < n; i++) {
+        if (s->statuses[i] != TEPTRIS_OK && first_fail == -1) first_fail = i;
+    }
+    if (first_fail != -1) {
+        const teptris_error *e = teptris_document_error(s->docs[first_fail]);
+        VALUE ex =
+            rb_exc_new(eParseError, e->message, (long)strlen(e->message));
+        rb_iv_set(ex, "@line", SIZET2NUM(e->line));
+        rb_iv_set(ex, "@column", SIZET2NUM(e->column));
+        for (long i = 0; i < n; i++) teptris_document_free(s->docs[i]);
+        batch_scratch_free(s);
+        rb_exc_raise(ex);
+    }
+    VALUE out = rb_ary_new_capa(n);
+    for (long i = 0; i < n; i++) {
+        lazy_owner *o;
+        VALUE owner = TypedData_Make_Struct(cLazyOwner, lazy_owner,
+                                            &lazy_owner_type, o);
+        o->doc = s->docs[i];
+        o->input = rb_ary_entry(strings, i);
+        rb_ary_push(out, lazy_wrap(owner, teptris_document_root(s->docs[i])));
+    }
+    batch_scratch_free(s);
+    return out;
+}
+
+/* Eager batch: returns Array of Hashes with the same datetime contract
+ * as ext_load. opts is parsed once; safe_load semantics apply uniformly.
+ * The caller's input Array is read-only; its strings stay referenced
+ * for the duration of the C call (no separate keeper Array). */
+static VALUE ext_load_batch(int argc, VALUE *argv, VALUE self) {
+    VALUE strings, opts;
+    rb_scan_args(argc, argv, "11", &strings, &opts);
+    Check_Type(strings, T_ARRAY);
+    long n = RARRAY_LEN(strings);
+    if (n == 0) return rb_ary_new();
+    unsigned flags = flags_from_opts(opts);
+    batch_scratch *s = batch_scratch_alloc(n);
+    if (s == NULL) rb_raise(eError, "out of memory batching %ld documents", n);
+    for (long i = 0; i < n; i++) {
+        VALUE str = rb_ary_entry(strings, i);
+        StringValue(str);
+        s->data[i] = RSTRING_PTR(str);
+        s->lens[i] = (size_t)RSTRING_LEN(str);
+    }
+    teptris_status batch =
+        teptris_parse_batch(s->data, s->lens, (size_t)n, NULL,
+                            s->docs, s->statuses);
+    if (batch != TEPTRIS_OK) {
+        batch_scratch_free(s);
+        rb_raise(eError, "batch parse failed (status %d)", (int)batch);
+    }
+    long first_fail = -1;
+    for (long i = 0; i < n; i++) {
+        if (s->statuses[i] != TEPTRIS_OK && first_fail == -1) first_fail = i;
+    }
+    if (first_fail != -1) {
+        const teptris_error *e = teptris_document_error(s->docs[first_fail]);
+        VALUE ex =
+            rb_exc_new(eParseError, e->message, (long)strlen(e->message));
+        rb_iv_set(ex, "@line", SIZET2NUM(e->line));
+        rb_iv_set(ex, "@column", SIZET2NUM(e->column));
+        for (long i = 0; i < n; i++) teptris_document_free(s->docs[i]);
+        batch_scratch_free(s);
+        rb_exc_raise(ex);
+    }
+    VALUE out = rb_ary_new_capa(n);
+    keycache kc;
+    kc_init(&kc); /* one cache across the batch: keys repeat across docs */
+    for (long i = 0; i < n; i++) {
+        const teptris_node *root = teptris_document_root(s->docs[i]);
+        rb_ary_store(out, i, obj_from_node(root, flags, &kc));
+        teptris_document_free(s->docs[i]);
+    }
+    kc_free(&kc);
+    batch_scratch_free(s);
+    return out;
+}
+
 void Init_teptris_ext(void) {
     VALUE m = rb_define_module("TeptrisExt");
     rb_define_module_function(m, "load", ext_load, -1);
+    rb_define_module_function(m, "load_lazy", ext_load_lazy, 1);
+    rb_define_module_function(m, "load_batch", ext_load_batch, -1);
+    rb_define_module_function(m, "load_lazy_batch", ext_load_lazy_batch, 1);
+    cLazyOwner = rb_define_class_under(m, "LazyOwner", rb_cObject);
+    cLazyValue = rb_define_class_under(m, "LazyValue", rb_cObject);
+    rb_define_method(cLazyValue, "kind", lazy_kind, 0);
+    rb_define_method(cLazyValue, "size", lazy_size, 0);
+    rb_define_method(cLazyValue, "each", lazy_each, 0);
+    rb_define_method(cLazyValue, "[]", lazy_get, 1);
+    rb_define_method(cLazyValue, "at", lazy_get, 1);
+    rb_define_method(cLazyValue, "dig", lazy_dig, -1);
+    rb_define_method(cLazyValue, "to_h", lazy_to, 0);
+    rb_define_method(cLazyValue, "to_a", lazy_to, 0);
+    rb_define_method(cLazyValue, "value", lazy_to, 0);
     rb_define_module_function(m, "dump", ext_dump, 1);
     rb_define_module_function(m, "engine_version", ext_version, 0);
     rb_define_module_function(m, "plan_build", ext_plan_build, 2);
@@ -605,4 +1063,6 @@ void Init_teptris_ext(void) {
     cDate = rb_const_get(rb_cObject, rb_intern("Date"));
     id_utc_offset = rb_intern("utc_offset");
     id_to_s = rb_intern("to_s");
+    id_to_i = rb_intern("to_i");
+    id_nsec = rb_intern("nsec");
 }

data/lib/teptris/toml.rb

@@ -36,6 +36,42 @@ module Teptris
         TeptrisExt.load(toml, opts)
       end
 
+      # Lazy load: returns a wrapper that parses eagerly (one pass)
+      # but materializes host objects only along the paths actually
+      # accessed. Same datetime contract as load; to_h/to_a flatten to
+      # the eager shape.
+      def load_lazy(toml)
+        raise ArgumentError, "input must be a String" unless toml.is_a?(String)
+
+        TeptrisExt.load_lazy(toml)
+      end
+
+      # Many-small batch path (teptris-ruby#108 ask 3): parse N inputs
+      # in one C call, share the safe_load/datetime_policy options
+      # struct across the batch, return one eager Hash per document.
+      # Same datetime contract as load. A failing document raises
+      # Teptris::ParseError carrying the first failure's line/column.
+      def load_batch(tomls, safe_load: nil, datetime_policy: :native)
+        _validate_batch!(tomls, safe_load, datetime_policy)
+        TeptrisExt.load_batch(tomls, _safe_load_opts(safe_load, datetime_policy))
+      end
+
+      # Lazy twin of load_batch: parse N inputs eagerly, hand back an
+      # Array of Lazy wrappers — materialization happens only on access.
+      # Same per-doc error semantics as load_lazy (first failure raises).
+      def load_lazy_batch(tomls)
+        _validate_batch!(tomls, nil, :native)
+        TeptrisExt.load_lazy_batch(tomls)
+      end
+
+      # Many-small path with file paths: read each file, then call
+      # load_batch. Symmetric with load_file's single-doc shape.
+      def load_files(paths, safe_load: nil, datetime_policy: :native)
+        _validate_batch!(paths, safe_load, datetime_policy, kind: :paths)
+        load_batch(paths.map { |p| File.read(p) },
+                   safe_load: safe_load, datetime_policy: datetime_policy)
+      end
+
       # One-pass schema materialization over a compiled
       # Teptris::Descriptor: unplanned keys are never materialized
       # (teptris#46).
@@ -61,6 +97,31 @@ module Teptris
       def dump(obj)
         TeptrisExt.dump(obj)
       end
+
+      private
+
+      def _validate_batch!(input, safe_load, datetime_policy, kind: :strings)
+        unless input.is_a?(Array)
+          raise ArgumentError, "expected Array of #{kind}, got #{input.class}"
+        end
+        if !safe_load.nil? && !safe_load.is_a?(Array) && !safe_load.is_a?(Symbol)
+          raise ArgumentError, "safe_load must be nil, an Array, or a Symbol"
+        end
+        unless %i[native string].include?(datetime_policy)
+          raise ArgumentError, "datetime_policy must be :native or :string"
+        end
+      end
+
+      def _safe_load_opts(safe_load, datetime_policy)
+        opts = {}
+        opts[:string_datetimes] = true if datetime_policy == :string
+        if safe_load && datetime_policy == :native
+          permitted = Array(safe_load) + [:__scalar]
+          opts[:forbid_time] = true unless permitted.include?(Time)
+          opts[:forbid_date] = true unless permitted.include?(Date)
+        end
+        opts.empty? ? nil : opts
+      end
     end
   end
 end

data/lib/teptris/version.rb

@@ -1,3 +1,3 @@
 module Teptris
-  VERSION = "0.2.42"
+  VERSION = "0.2.48"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: teptris
 version: !ruby/object:Gem::Version
-  version: 0.2.42
+  version: 0.2.48
 platform: arm-linux
 authors:
 - teptris contributors
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-20 00:00:00.000000000 Z
+date: 2026-09-26 00:00:00.000000000 Z
 dependencies: []
 description: A native C extension over libteptris, a C99 TOML 1.1 parser/emitter.
   API shape mirrors the tomlib gem.
@@ -51,7 +51,9 @@ files:
 - ext/teptris_ext/extconf.rb
 - ext/teptris_ext/materialize.c
 - lib/teptris.rb
-- lib/teptris/3.2/teptris_ext.so
+- lib/teptris/3.3/teptris_ext.so
+- lib/teptris/3.4/teptris_ext.so
+- lib/teptris/4.0/teptris_ext.so
 - lib/teptris/descriptor.rb
 - lib/teptris/error.rb
 - lib/teptris/toml.rb
@@ -75,7 +77,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.20
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: TOML for Ruby at libteptris speed (native C extension)