Accept directly readable ALTREP data in the layout oracle

Author: shikokuchuo

AGENTS.md

@@ -52,7 +52,7 @@ All writers are count-then-write pairs: `mori_serialize_count`/`mori_serialize_i
 
 Declared in `mori.h`, C-level only (not `.Call`) — for packages embedding mori layouts under their own SHM management:
 
-- **Layout oracle + writer**: `mori_layout_size(x)` → region size, or 0 for what the writer must not take (non-mori ALTREP nodes — would materialize via `DATAPTR_RO`). The S4 object bit rides the layouts: header flags word at offset 32 (`MORI_FLAG_S4`) for MORH/MORS/MORL roots and nested lists, bit 30 of the directory entry's `sexptype` (`MORI_ELEM_S4`) for vector/string leaves; applied with `Rf_asS4` after attributes land. Vetoes ride the size recursion (`mori_layout_size_impl` with `ok != NULL`); the host path passes `NULL` and vetoes nothing. `mori_layout_write(base, x)` emits exactly `mori_layout_size` bytes and zeroes reserved header bytes [24-63] on every write (embedders may recycle regions).
+- **Layout oracle + writer**: `mori_layout_size(x)` → region size, or 0 for what the writer must not take (ALTREP nodes that are neither mori views nor directly readable with no keeper chain — `mori_altrep_readable`; R's S4 data-part wrappers qualify). The S4 object bit rides the layouts: header flags word at offset 32 (`MORI_FLAG_S4`) for MORH/MORS/MORL roots and nested lists, bit 30 of the directory entry's `sexptype` (`MORI_ELEM_S4`) for vector/string leaves; applied with `Rf_asS4` after attributes land. Vetoes ride the size recursion (`mori_layout_size_impl` with `ok != NULL`); the host path passes `NULL` and vetoes nothing. `mori_layout_write(base, x)` emits exactly `mori_layout_size` bytes and zeroes reserved header bytes [24-63] on every write (embedders may recycle regions).
 - **Wrap constructors**: `mori_vec_wrap` / `mori_str_wrap` / `mori_list_wrap` build views over embedder memory, pinning `keeper` via the data1 extptr's protected slot; each takes a `release` once-hook (see Internal State). `mori_restore_attrs` reapplies trailing serialized attributes.
 - **Introspection + path walk**: `mori_view_check`, `mori_shm_name`, `mori_parse_id`, `mori_walk_path` (walks an index path over an open region; the caller's keeper flows into the result's chain).
 - **Wire hooks**: `mori_set_wire_hooks(emit, resolve)` — see Serialization Hooks.

src/altrep.c

@@ -850,8 +850,11 @@ static size_t mori_nested_write(unsigned char *base, SEXP x);
    LISTSXP children are coerced locally during recursion.
    ok is NULL on the host path. When non-NULL (the embedder layout oracle),
    each node is vetted before sizing and the first rejection sets *ok = 0 and
-   bails out with return 0: a non-mori ALTREP node would materialize through
-   DATAPTR_RO at write (a compact 1:1e8 becomes an 800 MB memcpy). */
+   bails out with return 0: an ALTREP node that is neither a mori view
+   nor directly readable with no keeper chain (mori_altrep_readable)
+   would materialize through DATAPTR_RO at write or duplicate a wire
+   identity (a compact 1:1e8 becomes an 800 MB memcpy). R's S4 data-part
+   wrappers forward to their materialized data part and are accepted. */
 static size_t mori_nested_size(SEXP x, int *ok) {
 
   R_xlen_t n = XLENGTH(x);
@@ -861,7 +864,9 @@ static size_t mori_nested_size(SEXP x, int *ok) {
     SEXP elt = VECTOR_ELT(x, i);
 
     if (ok != NULL) {
-      if (ALTREP(elt) && !mori_view_check(elt)) { *ok = 0; return 0; }
+      if (ALTREP(elt) && !mori_view_check(elt) && !mori_altrep_readable(elt)) {
+        *ok = 0; return 0;
+      }
     }
 
     int type = TYPEOF(elt);
@@ -1098,7 +1103,9 @@ static void mors_write(unsigned char *base, SEXP x) {
    header. */
 static size_t mori_layout_size_impl(SEXP x, int *ok) {
   if (ok != NULL) {
-    if (ALTREP(x) && !mori_view_check(x)) { *ok = 0; return 0; }
+    if (ALTREP(x) && !mori_view_check(x) && !mori_altrep_readable(x)) {
+      *ok = 0; return 0;
+    }
   }
   int type = TYPEOF(x);
   /* An S4 pairlist root passes through: VECSXP coercion drops the bit. */

src/mori.h

@@ -80,6 +80,20 @@ static inline size_t mori_sizeof_elt(int type) {
   }
 }
 
+/* R's S4 data-part wrapper is an ALTREP that forwards every data method
+   to the wrapped vector (data1): directly readable, no compression, no
+   keeper chain. Recognize it by that shape — a non-ALTREP data1 of the
+   same type whose data pointer the wrapper shares. Anything else foreign
+   (a lazy ALTREP, a materialized compact sequence, an extptr-data1 view)
+   is rejected: the layout write would materialize it or forfeit its
+   compact wire form. */
+static inline int mori_altrep_readable(SEXP x) {
+  SEXP inner = R_altrep_data1(x);
+  if (ALTREP(inner) || TYPEOF(inner) != TYPEOF(x)) return 0;
+  const void *pi = DATAPTR_OR_NULL(inner);
+  return pi != NULL && DATAPTR_OR_NULL(x) == pi;
+}
+
 /* Apply a region header's S4 flag to a freshly wrapped view — after
    attributes land, so a read never consults a class definition
    (Rf_asS4 with complete = 0 sets the bit in place on a fresh object).
@@ -117,9 +131,11 @@ void mori_restore_attrs(SEXP result, unsigned char *buf, size_t size);
 
 /* Layout oracle and writer for embedder-managed regions: the size pass
    walks the tree and returns 0 for anything the layout writer must not
-   take (a non-mori ALTREP node would materialize through DATAPTR_RO).
-   The write emits exactly mori_layout_size bytes and zeroes header
-   reserved bytes. */
+   take: an ALTREP node is rejected unless it is a mori view (rides the
+   wire hooks) or mori_altrep_readable (R's S4 data-part wrappers
+   qualify; a compact 1:1e8 would materialize through DATAPTR_RO at
+   write). The write emits exactly mori_layout_size bytes and zeroes
+   header reserved bytes. */
 size_t mori_layout_size(SEXP x);
 void mori_layout_write(unsigned char *base, SEXP x);