teptris 0.2.43-aarch64-linux → 0.2.45-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ac18ac8a6cebdd4a8c472afa9a733942405a254240b3b275773d26024c5a38de
-  data.tar.gz: 3cec224be95f07f9c7da0d2c45ca7696fff224485d5a34c68b285cdb13acb922
+  metadata.gz: 1764c42e95d80a0e2f467eff03795b059907ea88e2fec262f27cd6662c781e1b
+  data.tar.gz: c232f96abc11a711763e570d9395a9580be9a3c60ed1edd7206adbb1f84d8d09
 SHA512:
-  metadata.gz: 8693b62b569b6c5d58da145c9401d7564aa088a8dfd93c096c1c68cbdb6ec75006e3a7218aa698824fff4877928a4660ccafb70fd0c610ed23aa316c87e18761
-  data.tar.gz: e061031c34434624d8029eafc6b6822e3d29a79fb9e2e6f5e3db8db475f7d68cca49a343be73121b200004e0ba78da8dafb4bed7e1d3883600d067e161e4fd6e
+  metadata.gz: 29b39762ba7081b0c3e4c84cdec49e9ab8cbc97ce67399cbb402543221f1e10c922a57d497d6936441cacc96b920b29e1f2af864d3183ac5d6d44490154ee4da
+  data.tar.gz: 62285a34f34dca9a84d7667ee60ac3a37b1592a8284c1deccf10687cc6e60aa974262b6f9f5b578fd277bc5c9c75bc7907a850fd65a185bf8515ecaff0d20875

data/ext/teptris_ext/engine/README.md

@@ -1,4 +1,4 @@
-# libteptris 0.1.24 — vendored source
+# libteptris 0.1.26 — 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 25
+#define TEPTRIS_VERSION_STRING "0.1.25"
 
 #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

@@ -51,7 +51,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);
@@ -590,9 +602,359 @@ 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);
+    return obj_from_node(v->node, 0);
+}
+
+/* ---------------------------------------------------------------- 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);
+    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));
+        teptris_document_free(s->docs[i]);
+    }
+    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);

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.43"
+  VERSION = "0.2.45"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: teptris
 version: !ruby/object:Gem::Version
-  version: 0.2.43
+  version: 0.2.45
 platform: aarch64-linux
 authors:
 - teptris contributors
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-21 00:00:00.000000000 Z
+date: 2026-09-22 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.