cid(advance): Generalize video API to accept borrowed slices

Change soft_hash_video_v0 and gen_video_code_v0 from &[Vec<i32>] to
generic <S: AsRef<[i32]> + Ord>, eliminating per-frame heap allocations
in the FFI crate while remaining backward-compatible with all bindings.

Author: CID Agent

.claude/agent-memory/advance/MEMORY.md

@@ -185,6 +185,15 @@ iterations.
     `drop(chunks)`, then mutate `self.buf`. Explicit `drop(chunks)` makes the borrow release visible
 - Benchmark: `DataHasher` streaming at 64 KiB chunks on 1 MB data achieves ~1.1 GiB/s throughput
 
+## API Generics
+
+- Video API (`soft_hash_video_v0`, `gen_video_code_v0`) uses `<S: AsRef<[i32]> + Ord>` instead of
+    concrete `&[Vec<i32>]`. This allows FFI to pass `&[&[i32]]` (zero-copy borrows) while other
+    bindings continue passing `&[Vec<i32>]` unchanged. `AsRef<[i32]>` gives slice access, `Ord`
+    enables `BTreeSet` deduplication. Body uses `.as_ref()` for element access
+- FFI video wrappers use `Vec<&[i32]>` (1 remaining `.to_vec()` in FFI crate is for
+    `alg_cdc_chunks`)
+
 ## Gotchas
 
 - `pop_local_frame` is `unsafe` in jni crate v0.21 (Rust 2024 edition) — must wrap in `unsafe {}`

.claude/context/handoff.md

@@ -1,29 +1,33 @@
-## 2026-02-25 — Review of: Optimize DataHasher::update buffer allocation
+## 2026-02-25 — Generalize video API to accept borrowed slices
 
-**Verdict:** PASS
+**Done:** Changed `soft_hash_video_v0` and `gen_video_code_v0` from concrete `&[Vec<i32>]` to
+generic `<S: AsRef<[i32]> + Ord>` parameters. Updated both FFI wrappers to construct `Vec<&[i32]>`
+(borrowed slices) instead of `Vec<Vec<i32>>` (heap-allocated copies), eliminating per-frame
+allocations.
 
-**Summary:** Replaced per-call heap allocations in `DataHasher::update` with a persistent
-`buf: Vec<u8>` that is reused across calls. The `data.to_vec()`, `[tail, data].concat()`, and
-`prev_chunk.to_vec()` patterns are eliminated — new data is appended via `extend_from_slice`, and
-the tail is shifted to the front with `copy_within` + `truncate`. A Criterion streaming benchmark
-was added. All 261 tests pass, clippy clean, 14 pre-commit hooks pass, benchmark runs at ~1.0 GiB/s.
+**Files changed:**
 
-**Verification:**
-
-- [x] `cargo test -p iscc-lib` passes — 261 tests (208 + 31 + 22), 0 failures
-- [x] `cargo clippy -p iscc-lib -- -D warnings` clean
-- [x] `grep -c 'to_vec\|\.concat()' crates/iscc-lib/src/streaming.rs` returns 0 — no per-call
-    allocations remain
-- [x] `cargo bench -p iscc-lib -- DataHasher` runs successfully — ~1.0 GiB/s throughput
-
-**Issues found:**
+- `crates/iscc-lib/src/lib.rs`: Generalized `soft_hash_video_v0` and `gen_video_code_v0` signatures
+    to `<S: AsRef<[i32]> + Ord>`. Updated body to use `.as_ref()` for column count and iteration,
+    and `BTreeSet<&S>` for deduplication.
+- `crates/iscc-ffi/src/lib.rs`: Changed both `iscc_gen_video_code_v0` and `iscc_soft_hash_video_v0`
+    from `Vec<Vec<i32>>` with `.to_vec()` to `Vec<&[i32]>` with direct slice borrows.
 
-- (none)
-
-**Next:** The `[normal]` DataHasher issue is resolved. Consider the `[normal]` iscc-ffi video frame
-allocation issue (changing `iscc_lib` video API to accept `&[&[i32]]`), or one of the `[low]` issues
-(dct power-of-two validation, wtahash bounds check, iscc-py `__version__`, etc.).
+**Verification:**
 
-**Notes:** The borrow checker pattern (extract `tail_len` as `usize` before `drop(chunks)`) is clean
-and well-documented with inline comments. The `drop(chunks)` is explicit to make the borrow release
-obvious — good practice for code that manipulates borrowed data and the owning buffer in sequence.
+- `cargo test -p iscc-lib`: 261 tests passed (208 + 31 + 22), 0 failures
+- `cargo test -p iscc-ffi`: 62 tests passed, 0 failures
+- `cargo clippy --workspace --all-targets -- -D warnings`: clean (no warnings)
+- `.to_vec()` count in `crates/iscc-ffi/src/lib.rs`: 1 (only the unrelated `alg_cdc_chunks` on line
+    906 remains — down from 3)
+- `mise run check`: all 14 pre-commit hooks passed
+
+**Next:** The `[normal]` iscc-ffi video frame allocation issue is resolved. Consider the remaining
+`[low]` issues: `alg_dct` power-of-two validation, `alg_wtahash` bounds check, iscc-py
+`__version__`, iscc-py module docstring, iscc-wasm conformance feature gate, or iscc-wasm stale
+CLAUDE.md.
+
+**Notes:** The generic approach (`AsRef<[i32]> + Ord`) was chosen over concrete `&[&[i32]]` to
+maintain backward compatibility — all existing callers that pass `&[Vec<i32>]` compile unchanged
+because `Vec<i32>` implements both traits. Only the FFI crate (the actual beneficiary) was modified.
+No other binding crate (py, napi, wasm, jni) required changes.

crates/iscc-ffi/src/lib.rs

@@ -406,12 +406,12 @@ pub unsafe extern "C" fn iscc_gen_video_code_v0(
     let sig_ptrs = unsafe { std::slice::from_raw_parts(frame_sigs, num_frames) };
     let lens = unsafe { std::slice::from_raw_parts(frame_lens, num_frames) };
 
-    let frames: Vec<Vec<i32>> = sig_ptrs
+    let frames: Vec<&[i32]> = sig_ptrs
         .iter()
         .zip(lens.iter())
         .map(|(&ptr, &len)| {
             // SAFETY: caller guarantees each ptr is valid for its length
-            unsafe { std::slice::from_raw_parts(ptr, len) }.to_vec()
+            unsafe { std::slice::from_raw_parts(ptr, len) }
         })
         .collect();
 
@@ -956,12 +956,12 @@ pub unsafe extern "C" fn iscc_soft_hash_video_v0(
     let sig_ptrs = unsafe { std::slice::from_raw_parts(frame_sigs, num_frames) };
     let lens = unsafe { std::slice::from_raw_parts(frame_lens, num_frames) };
 
-    let frames: Vec<Vec<i32>> = sig_ptrs
+    let frames: Vec<&[i32]> = sig_ptrs
         .iter()
         .zip(lens.iter())
         .map(|(&ptr, &len)| {
             // SAFETY: caller guarantees each ptr is valid for its length
-            unsafe { std::slice::from_raw_parts(ptr, len) }.to_vec()
+            unsafe { std::slice::from_raw_parts(ptr, len) }
         })
         .collect();
 

crates/iscc-lib/src/lib.rs

@@ -522,21 +522,24 @@ pub fn gen_audio_code_v0(cv: &[i32], bits: u32) -> IsccResult<AudioCodeResult> {
 ///
 /// Deduplicates frame signatures, computes column-wise sums across all
 /// unique frames, then applies WTA-Hash to produce a digest of `bits/8` bytes.
-pub fn soft_hash_video_v0(frame_sigs: &[Vec<i32>], bits: u32) -> IsccResult<Vec<u8>> {
+pub fn soft_hash_video_v0<S: AsRef<[i32]> + Ord>(
+    frame_sigs: &[S],
+    bits: u32,
+) -> IsccResult<Vec<u8>> {
     if frame_sigs.is_empty() {
         return Err(IsccError::InvalidInput(
             "frame_sigs must not be empty".into(),
         ));
     }
 
-    // Deduplicate using BTreeSet (Vec<i32> implements Ord)
-    let unique: std::collections::BTreeSet<&Vec<i32>> = frame_sigs.iter().collect();
+    // Deduplicate using BTreeSet (S: Ord)
+    let unique: std::collections::BTreeSet<&S> = frame_sigs.iter().collect();
 
     // Column-wise sum into i64 to avoid overflow
-    let cols = frame_sigs[0].len();
+    let cols = frame_sigs[0].as_ref().len();
     let mut vecsum = vec![0i64; cols];
     for sig in &unique {
-        for (c, &val) in sig.iter().enumerate() {
+        for (c, &val) in sig.as_ref().iter().enumerate() {
             vecsum[c] += val as i64;
         }
     }
@@ -548,7 +551,10 @@ pub fn soft_hash_video_v0(frame_sigs: &[Vec<i32>], bits: u32) -> IsccResult<Vec<
 ///
 /// Produces an ISCC Content-Code for video from a sequence of MPEG-7 frame
 /// signatures. Each frame signature is a 380-element integer vector.
-pub fn gen_video_code_v0(frame_sigs: &[Vec<i32>], bits: u32) -> IsccResult<VideoCodeResult> {
+pub fn gen_video_code_v0<S: AsRef<[i32]> + Ord>(
+    frame_sigs: &[S],
+    bits: u32,
+) -> IsccResult<VideoCodeResult> {
     let digest = soft_hash_video_v0(frame_sigs, bits)?;
     let component = codec::encode_component(
         codec::MainType::Content,