Remove OIIO adapter; add FlatHost export

Remove the in-library OIIO adapter and replace the OIIO naming surface with a neutral flat-host export style. Deleted oiio_adapter header/impl and tests, removed oiio entries from CMakeLists and test lists. Update interop_export to rename OIIO -> FlatHost (ExportNameStyle, mapping functions, builders) and expose visit_metadata/ExportOptions as the intended host-owned traversal surface. Replace references across docs and sphinx sources to describe host-owned metadata mapping, EXR host-apply adapters, and the FlatHost naming policy. metadata_transfer now includes interop_export and safety/format internals and adds helpers for EXR projected text handling. Overall goal: move host-specific payload/attribute mapping out of library internals and steer integrations toward visit_metadata and dedicated host adapters.

Author: ssh4net

CMakeLists.txt

@@ -261,7 +261,6 @@ set(OPENMETA_SOURCES
   src/openmeta/meta_edit.cc
   src/openmeta/meta_value.cc
   src/openmeta/ocio_adapter.cc
-  src/openmeta/oiio_adapter.cc
   src/openmeta/photoshop_irb_decode.cc
   src/openmeta/preview_extract.cc
   src/openmeta/printim_decode.cc
@@ -614,7 +613,6 @@ if(OPENMETA_BUILD_TESTS)
     tests/meta_store_test.cc
     tests/mpf_decode_test.cc
     tests/ocio_adapter_test.cc
-    tests/oiio_adapter_test.cc
     tests/photoshop_irb_decode_test.cc
     tests/preview_extract_test.cc
     tests/printim_decode_test.cc

README.md

@@ -48,7 +48,7 @@ That guide covers the shortest useful paths for:
 - reading and querying metadata in C++
 - building and editing `MetaStore`
 - copying metadata into an existing JPEG, TIFF, or DNG target
-- building EXR and OIIO-style host-API metadata outputs
+- building EXR and host-API metadata outputs
 - using the optional Adobe DNG SDK bridge
 
 If you already own the encoder, SDK objects, or output container, follow

docs/development.md

@@ -813,8 +813,8 @@ Read release gate:
   - `SimpleMetaRead.*`
   - `XmpDecodeTest.*`
   - `JumbfDecode.*`
-  - `OiioAdapter.*`
   - `OcioAdapter.*`
+  - `ExrAdapter.*`
   - `ValidateFile.*`
 
 Build + run:
@@ -1059,84 +1059,56 @@ If you are building offline (or want strict control of the build environment),
 install `scikit-build-core` into your Python environment and enable:
 `-DOPENMETA_WHEEL_NO_BUILD_ISOLATION=ON`.
 
-## Interop Adapters
+## Interop Surfaces
 
-Interop adapter APIs for ASF integration targets:
+Interop surfaces are split deliberately:
 
-- `openmeta/interop_export.h`: shared traversal and naming styles
-  (`Canonical`, `XmpPortable`, `Oiio`).
-- `openmeta/oiio_adapter.h`: flat OIIO-style name/value export.
-- `openmeta/ocio_adapter.h`: deterministic OCIO-style metadata tree export.
-- `openmeta/exr_adapter.h`: EXR-native per-part attribute export.
+- export-only naming/traversal surface:
+  `openmeta/interop_export.h` with the shared export naming styles. This is
+  the intended base for host-owned metadata mapping layers.
+- export-only adapter:
+  `openmeta/ocio_adapter.h` for deterministic OCIO-style metadata trees.
+- host-apply adapter:
+  `openmeta/exr_adapter.h` for EXR-native per-part attribute export.
+- direct bridge:
+  `openmeta/dng_sdk_adapter.h` for applications that already use Adobe DNG
+  SDK objects/files.
+- narrow translator:
+  `openmeta/libraw_adapter.h` for explicit orientation mapping into LibRaw's
+  flip convention.
 
 Current Python binding entry points:
 
 - `Document.export_names(style=..., include_makernotes=...)`
-- `Document.oiio_attributes(...)`
-- `Document.unsafe_oiio_attributes(...)`
-- `Document.oiio_attributes_typed(...)`
-- `Document.unsafe_oiio_attributes_typed(...)`
 - `Document.ocio_metadata_tree(...)`
 - `Document.unsafe_ocio_metadata_tree(...)`
 - `Document.dump_xmp_sidecar(format=...)`
 
-Current C++ adapter entry points:
-
-- `openmeta/oiio_adapter.h`:
-  - safe API: `collect_oiio_attributes_safe(..., InteropSafetyError*)`
-  - unsafe API: `collect_oiio_attributes(...)`
-  - `collect_oiio_attributes(..., const OiioAdapterRequest&)` (stable flat request API)
-  - `collect_oiio_attributes(..., const OiioAdapterOptions&)` (advanced/legacy shape)
-  - safe typed API: `collect_oiio_attributes_typed_safe(..., InteropSafetyError*)`
-  - unsafe typed API: `collect_oiio_attributes_typed(...)`
-  - `collect_oiio_attributes_typed(..., const OiioAdapterRequest&)` (typed values)
-  - `collect_oiio_attributes_typed(..., const OiioAdapterOptions&)` (typed values)
-  - typed payload model: `OiioTypedValue` / `OiioTypedAttribute`
-  - prepared transfer bridge:
-    `collect_oiio_transfer_payload_views(...)`
-    returns one zero-copy payload list over a `PreparedTransferBundle`
-    for host/plugin write integrations
-  - owned transfer bridge:
-    `build_oiio_transfer_payload_batch(...)`
-    copies that same payload contract into one stable owned batch for caching
-    or cross-layer handoff
-  - persisted payload bridge:
-    `collect_oiio_transfer_payload_views(const PreparedTransferPayloadBatch&, ...)`
-    and `replay_oiio_transfer_payload_batch(...)`
-    consume the same semantic payload contract after
-    `serialize_prepared_transfer_payload_batch(...)` /
-    `deserialize_prepared_transfer_payload_batch(...)`
+Current C++ interop entry points:
+
+- `openmeta/interop_export.h`:
+  - `visit_metadata(...)`
+  - use the shared naming styles when a host-owned metadata mapping layer
+    needs deterministic exported names
 - `openmeta/exr_adapter.h`:
   - `build_exr_attribute_batch(...)`
-    exports one owned EXR-native attribute batch from `MetaStore`
-  - the batch carries:
-    `part_index`, `name`, `type_name`, `value` bytes, and `is_opaque`
   - `build_exr_attribute_part_spans(...)`
-    groups the batch into deterministic contiguous per-part spans
   - `build_exr_attribute_part_views(...)`
-    exposes zero-copy grouped per-part views over the same batch
   - `replay_exr_attribute_batch(...)`
-    replays the grouped batch through explicit host callbacks
-  - unlike the prepared JPEG/TIFF/JXL transfer path, this bridge is
-    store-based because typed `MetaValue` entries must be re-encoded into EXR
-    attribute bytes
-
-Python typed behavior:
-- `Document.oiio_attributes(...)` is safe-by-default and raises on unsafe raw
-  byte payloads; use `Document.unsafe_oiio_attributes(...)` for legacy/raw
-  fallback output.
-- `Document.oiio_attributes_typed(...)` decodes text values to Python `str` in
-  safe mode and raises on unsafe/invalid text bytes.
-- `Document.unsafe_oiio_attributes_typed(...)` returns raw text bytes for
-  explicit unsafe workflows.
-- `Document.ocio_metadata_tree(...)` is safe-by-default and raises on unsafe
-  raw byte payloads; use `Document.unsafe_ocio_metadata_tree(...)` for
-  legacy/raw fallback output.
+  - the batch carries:
+    `part_index`, `name`, `type_name`, `value` bytes, and `is_opaque`
 - `openmeta/ocio_adapter.h`:
   - safe API: `build_ocio_metadata_tree_safe(..., InteropSafetyError*)`
   - unsafe API: `build_ocio_metadata_tree(...)`
-  - `build_ocio_metadata_tree(..., const OcioAdapterRequest&)` (stable flat request API)
-  - `build_ocio_metadata_tree(..., const OcioAdapterOptions&)` (advanced/legacy shape)
+  - `build_ocio_metadata_tree(..., const OcioAdapterRequest&)`
+  - `build_ocio_metadata_tree(..., const OcioAdapterOptions&)`
+
+Python interop behavior:
+- `Document.export_names(style=ExportNameStyle.FlatHost, ...)` exposes the
+  shared flat-host naming contract used by host-side metadata mapping layers.
+- `Document.ocio_metadata_tree(...)` is safe-by-default and raises on unsafe
+  raw byte payloads; use `Document.unsafe_ocio_metadata_tree(...)` for
+  legacy/raw fallback output.
 
 Current C++ sidecar entry points:
 
@@ -1255,36 +1227,20 @@ Draft C++ transfer entry points (prepare/emit scaffold):
     without pushing route parsing into host adapters.
   - `replay_prepared_transfer_package_batch(...)` is the matching target-neutral
     callback replay path over the same persisted batch.
-  - `collect_oiio_transfer_package_views(...)` is the first host bridge above
-    that persisted batch: it now maps the target-neutral semantic package view
-    into OIIO-oriented names, so the host no longer depends on the original
-    prepared bundle lifetime or route parsing.
-  - `collect_oiio_transfer_payload_views(...)` and
-    `build_oiio_transfer_payload_batch(...)` now sit on top of the generic
-    semantic payload layer rather than re-classifying prepared blocks inside
-    the OIIO adapter.
-  - `replay_oiio_transfer_package_batch(...)` is the higher-level consume path
-    above that same persisted batch, replaying semantic package chunks through
-    explicit host callbacks in deterministic output order.
-    - `PreparedTransferAdapterView` is the parallel adapter-facing surface for
-      host integrations that want explicit per-block operations without route
-      parsing.
-    - `collect_oiio_transfer_payload_views(...)` is the first thin
-      host-facing bridge on top of that adapter view, exposing one zero-copy
-      OIIO-oriented semantic payload list without adding new transfer core
-      logic.
-    - `build_oiio_transfer_payload_batch(...)` is the owned form of that
-      bridge when the host needs payload lifetime independent from the
-      prepared bundle.
-    - `build_exr_attribute_batch(...)`,
-      `build_exr_attribute_part_spans(...)`,
-      `build_exr_attribute_part_views(...)`, and
-      `replay_exr_attribute_batch(...)` are the EXR-native bridge for
-      OpenEXR/OIIO header-attribute workflows. They stay outside the
-      `PreparedTransferBundle` path because EXR metadata is attribute-native,
-      not block-native.
-    - `build_prepared_transfer_emit_package(...)`,
-      `build_prepared_transfer_adapter_view(...)`,
+  - OpenMeta no longer ships an in-library host-specific payload/package
+    bridge above the target-neutral package and adapter surfaces.
+  - `PreparedTransferAdapterView` is the parallel adapter-facing surface for
+    host integrations that want explicit per-block operations without route
+    parsing.
+  - `build_exr_attribute_batch(...)`,
+    `build_exr_attribute_part_spans(...)`,
+    `build_exr_attribute_part_views(...)`, and
+    `replay_exr_attribute_batch(...)` are the EXR-native bridge for
+    OpenEXR header-attribute workflows. They stay outside the
+    `PreparedTransferBundle` path because EXR metadata is attribute-native,
+    not block-native.
+  - `build_prepared_transfer_emit_package(...)`,
+    `build_prepared_transfer_adapter_view(...)`,
       `emit_prepared_transfer_adapter_view(...)`,
       `build_prepared_bundle_jpeg_package(...)`,
       `build_prepared_bundle_tiff_package(...)`, and
@@ -1328,27 +1284,29 @@ Current adapter/name-policy behavior:
 - `ExportNamePolicy::ExifToolAlias` applies compatibility aliases for
   interop-name parity workflows.
 - `ExportNamePolicy::Spec` preserves spec/native names.
-- OIIO adapter keeps numeric unknown names (for example `Exif_0x....`) even
-  when value formatting is empty, and keeps `Exif:MakerNote` in spec mode.
+- Shared flat-host interop naming keeps numeric unknown names (for example
+  `Exif_0x....`) for parity workflows.
 - When DNG context is detected (`DNGVersion` present in the same IFD), DNG
   color/CCM tags are exported with dedicated adapter namespaces:
-  `dng:*` (portable) and `DNG:*` (OIIO).
+  `dng:*` (portable) and a flat host-style variant.
 - ICC entries are exported with adapter-friendly names:
-  `icc:*` (portable) and `ICC:*` (OIIO), alongside canonical `icc:header:*`
-  / `icc:tag:*` naming.
+  `icc:*` (portable) and a flat host-style variant, alongside canonical
+  `icc:header:*` / `icc:tag:*` naming.
 
 Adapter-focused tests (public tree):
 
 ```bash
 cmake --build build-tests --target openmeta_tests
-./build-tests/openmeta_tests --gtest_filter='InteropExport.*:OiioAdapter.*:OcioAdapter.*'
+./build-tests/openmeta_tests --gtest_filter='InteropExport.*:OcioAdapter.*:ExrAdapter.*'
+./build-tests/openmeta_tests --gtest_filter='ExrAdapter.*'
 ./build-tests/openmeta_tests --gtest_filter='CrwCiffDecode.*'
 ```
 
 Notes:
+- `InteropExport` tests cover alias/spec behavior and the flat host-style
+  naming contract.
+- `ExrAdapter` tests cover EXR batch export and replay behavior.
 - `CrwCiffDecode` tests cover CRW/CIFF derived EXIF mapping for legacy Canon RAW.
-- `OiioAdapter` tests cover stable handling of empty-value attributes needed by
-  interop parity workflows.
 
 ## Doxygen (Optional)
 

docs/doxygen.md

@@ -1,7 +1,7 @@
 # Documentation
 
-OpenMeta uses Doxygen for API extraction. For the "site" style docs (like OIIO),
-we render Doxygen XML via Sphinx + Breathe.
+OpenMeta uses Doxygen for API extraction. For the published site docs, we
+render Doxygen XML via Sphinx + Breathe.
 
 ## Requirements
 

docs/host_integration.md

@@ -20,13 +20,28 @@ Use the narrowest public API that matches your host:
 | --- | --- |
 | Existing target file or template | `execute_prepared_transfer_file(...)` + `persist_prepared_transfer_file_result(...)` |
 | EXR writer | `build_exr_attribute_batch_from_file(...)` |
-| OIIO-style typed attributes | `collect_oiio_attributes_typed(...)` |
+| Host-owned metadata object model | `visit_metadata(...)` |
 | JPEG/JXL/WebP/PNG/JP2/BMFF encoder path | `prepare_metadata_for_target_file(...)` + adapter view or backend emitter |
 | Adobe DNG SDK objects/files | `dng_sdk_adapter.h` |
 
 There is no public fuzzy-search API yet. Query through exact keys and build
 your own display or search layer on top.
 
+## Adapter Classes
+
+OpenMeta splits host integration surfaces deliberately:
+
+- export-only naming/traversal surface:
+  `visit_metadata(...)` for host-owned metadata mapping layers
+- export-only adapter:
+  `build_ocio_metadata_tree(...)` for OCIO-style metadata trees
+- host-apply adapter:
+  `build_exr_attribute_batch(...)` for EXR/OpenEXR header workflows
+- direct bridge:
+  `dng_sdk_adapter.h` for applications that already use Adobe DNG SDK objects
+- narrow translator:
+  `libraw_adapter.h` for orientation mapping into LibRaw flip space
+
 ## 1. Read Into `MetaStore`
 
 ```cpp
@@ -80,23 +95,32 @@ for (openmeta::EntryId id : store.find_all(key)) {
 This is the public lookup model today. If you need fuzzy search, substring
 search, or ExifTool-style display lookup, add that in your application layer.
 
-## 3. Export Typed Metadata For OIIO-Style Hosts
+## 3. Generic Host Metadata Traversal
 
-Use this when the host wants flattened typed attributes instead of raw
-container payloads.
+Use the traversal API when your application owns the metadata object model and
+needs deterministic exported names plus the original `Entry`.
 
 ```cpp
-#include "openmeta/oiio_adapter.h"
+#include "openmeta/interop_export.h"
+
+class MyMetadataSink final : public openmeta::MetadataSink {
+public:
+    void on_item(const openmeta::ExportItem& item) noexcept override
+    {
+        // Map item.name + item.entry into your host metadata object.
+    }
+};
 
-std::vector<openmeta::OiioTypedAttribute> attrs;
-openmeta::OiioAdapterRequest request;
-request.include_makernotes = true;
+openmeta::ExportOptions options;
+options.style              = openmeta::ExportNameStyle::FlatHost;
+options.name_policy        = openmeta::ExportNamePolicy::ExifToolAlias;
+options.include_makernotes = true;
 
-openmeta::collect_oiio_attributes_typed(store, &attrs, request);
+MyMetadataSink sink;
+openmeta::visit_metadata(store, options, sink);
 ```
 
-That gives you `name + typed value` pairs that are easy to map onto an
-OpenImageIO `ImageSpec` or a similar metadata API.
+This keeps host-specific object ownership and write behavior outside OpenMeta.
 
 ## 4. Build An EXR Attribute Batch
 
@@ -118,8 +142,8 @@ for (const openmeta::ExrAdapterAttribute& attr : batch.attributes) {
 ```
 
 OpenMeta does not need OpenEXR headers for this path. It exports a neutral
-batch of EXR-style attributes that your host can apply through OpenEXR, OIIO,
-or its own EXR writer.
+batch of EXR-style attributes that your host can apply through OpenEXR or its
+own EXR writer.
 
 ## 5. Feed A Host-Owned JPEG Or JXL Encoder
 

docs/metadata_backend_matrix.md

@@ -14,7 +14,6 @@ backends without per-backend metadata logic duplication.
 | libjpeg-turbo | `jpeg_write_marker`, `jpeg_write_m_header`, `jpeg_write_m_byte`, `jpeg_write_icc_profile` | Primary JPEG metadata emitter (APP1/APP2/APP13 direct control) |
 | libtiff | `TIFFSetField`, `TIFFCreateEXIFDirectory`, `TIFFCreateGPSDirectory`, `TIFFWriteCustomDirectory`, `TIFFMergeFieldInfo` | Primary TIFF metadata emitter (native tag and IFD path) |
 | libjxl | `JxlEncoderUseBoxes`, `JxlEncoderAddBox`, `JxlEncoderCloseBoxes`, `JxlEncoderSetICCProfile` | Primary JXL metadata emitter (`Exif`, `xml `, `jumb`, optional `brob`) plus encoder ICC profile |
-| OpenImageIO | Plugin-level writes use backend APIs (JPEG/TIFF/JXL/OpenEXR) | Optional adapter layer when host app already writes through OIIO |
 | OpenEXR | `Header::insert`, typed attributes, `OpaqueAttribute` for unknown attr types | EXR header attribute path (not EXIF block packaging) |
 
 ## Container-Level Notes
@@ -293,7 +292,7 @@ container call mapping.
       input stream or prepared bundle storage.
     - `serialize_prepared_transfer_package_batch(...)` and
       `deserialize_prepared_transfer_package_batch(...)` persist that owned
-      batch so host layers can move it across process or plugin boundaries
+      batch so host layers can move it across process or integration boundaries
       without reopening the source file or rebuilding the bundle.
     - `collect_prepared_transfer_payload_views(...)` and
       `build_prepared_transfer_payload_batch(...)` now provide the matching
@@ -306,27 +305,16 @@ container call mapping.
       semantic package surface above that persisted batch.
     - `replay_prepared_transfer_package_batch(...)` is the target-neutral
       callback replay surface above that same persisted batch.
-    - `collect_oiio_transfer_package_views(...)` is the first host bridge on
-      top of that persisted batch: it provides zero-copy semantic package
-      views for OIIO-style integrations after deserialize by mapping the
-      target-neutral semantic surface into OIIO-facing names.
-    - `replay_oiio_transfer_package_batch(...)` is the higher-level replay
-      path on top of that same persisted batch, so OIIO/plugin hosts can
-      consume the stable package through callbacks without reparsing routes.
+    - OpenMeta no longer ships an in-library host-specific payload/package
+      bridge above these target-neutral package views and replay APIs.
     - `build_prepared_transfer_adapter_view(...)` now provides the parallel
       target-neutral adapter view for JPEG/TIFF/JXL host integrations that
       want explicit compiled operations without route parsing.
     - `emit_prepared_transfer_adapter_view(...)` replays that compiled view
       through one generic host sink.
-    - `collect_oiio_transfer_payload_views(...)` and
-      `build_oiio_transfer_payload_batch(...)` now sit on top of that core
-      semantic payload surface, mapping it into OIIO-facing names rather than
-      re-classifying prepared blocks inside the adapter.
-    - `replay_prepared_transfer_payload_batch(...)`,
-      `collect_oiio_transfer_payload_views(const PreparedTransferPayloadBatch&, ...)`,
-      and `replay_oiio_transfer_payload_batch(...)`
-      now reuse that same earlier persisted semantic payload stage directly,
-      before final package materialization.
+    - `replay_prepared_transfer_payload_batch(...)` now reuses that same
+      earlier persisted semantic payload stage directly, before final package
+      materialization.
     - File-based JPEG prepare can preserve an existing OpenMeta draft
       invalidation payload as raw APP11 C2PA (`TransferC2paMode::PreserveRaw`).
     - Content-bound `Keep` still resolves to `Drop`.
@@ -343,9 +331,9 @@ container call mapping.
 1. JPEG and TIFF direct backends (highest transfer value).
 2. JXL box emitter parity for EXIF/XMP plus bounded JUMBF/C2PA preserve or
    projection.
-3. Extend the new OIIO transfer bridge beyond the current zero-copy payload
-   view and owned batch if host-specific persistence or replay formats are
-   needed.
+3. If a future host-specific bridge needs persistence or replay formats,
+   build that on top of the target-neutral package and adapter surfaces
+   rather than adding a host-specific wrapper inside OpenMeta.
 4. Extend the current EXR attribute batch bridge if host-side replay or
    persistence formats are needed.