@logbrew/react-native 0.1.10 → 0.1.11

package/README.md

@@ -118,6 +118,73 @@ client key before creating a new client. A `429` preserves the queue and
 reports `pausedReason: "rate_limit"` plus the bounded retry signal exposed by
 the failed flush.
 
+## Offline And Restart Delivery
+
+The React Native entry uses an app-private native queue by default when the
+current app binary contains the linked LogBrew module. Each accepted event is
+written before it enters memory. After a JavaScript runtime or app restart,
+the client loads pending events oldest first with their original IDs. A
+successful intake response commits which records were accepted before removing
+them, so an interrupted removal can cause a duplicate but cannot silently lose
+an unaccepted event. Replayed events keep their stable IDs. Delivery is at
+least once, so apps must tolerate duplicates, including when retries regroup
+events into different batches.
+
+Inspect the delivery health snapshot to observe the active behavior:
+
+```js
+const health = client.deliveryHealth();
+if (health.storage !== "persistent") {
+  // The app is running without the linked native queue.
+}
+```
+
+The default `persistentQueue: "auto"` mode uses memory when the native module
+is absent, including Expo Go and an older app binary after a JavaScript-only
+update. For a production build that must not start without restart recovery,
+set `persistentQueue: "required"`. Use `persistentQueue: "disabled"` only
+when the app intentionally accepts a memory-only queue.
+
+```js
+const client = createLogBrewReactNativeClient({
+  clientKey,
+  persistentQueue: "required",
+  transport: createReactNativeFetchTransport()
+});
+```
+
+The native queue stores one compact event per atomic record, is limited to
+1,000 events and 4 MiB of compact event data, and uses the same smaller limits
+when you configure them on the client. Both platforms use app-private storage.
+The client key is not written to disk; its SHA-256 digest separates queues
+after key rotation. The queue does not provide mathematically exactly-once
+delivery.
+
+A successful `shutdown()` drains and closes the queue. A failed flush or
+shutdown leaves the exact remainder available to the same client and the next
+app start. Call `client.purgePendingEvents()` only when no flush or shutdown is
+active. To retire an active key without sending its remainder, purge that
+client first and then close it:
+
+```js
+client.purgePendingEvents();
+await client.shutdown();
+```
+
+When no client owns the key, remove any remaining records explicitly with:
+
+```js
+import { purgeLogBrewReactNativePersistentQueue } from "@logbrew/react-native";
+
+purgeLogBrewReactNativePersistentQueue({ clientKey: previousClientKey });
+```
+
+Use only one active persistent client for a given key across an app process.
+The SDK rejects duplicates within one JavaScript runtime; apps with multiple
+React Native runtimes or platform processes must coordinate that ownership.
+Different client keys use separate native queues. The Node ESM and CommonJS
+entries remain platform-neutral and never load React Native.
+
 ## Product Actions And API Milestones
 
 Use explicit action and network helpers for important mobile funnel steps your app already understands. These events are designed for timelines and agent analysis without enabling broad automatic replay:
@@ -202,7 +269,7 @@ Installation is idempotent for the active React Native `ErrorUtils` object. The
 
 The React Native conditional export obtains LogBrew's synchronous native fatal store through the supported TurboModule or `NativeModules` seam. Before chaining a fatal report, it writes one bounded record to app-private storage that is excluded from operating-system archives. On a later installation it performs stable-ID at-least-once replay, and acknowledgement happens only after local queue admission is observable through the SDK queue counters. Filtered, dropped, unknown-admission, persistence-failed, and acknowledgement-failed records are retained. A failed acknowledgement is retried without admitting the same ID twice in one JavaScript runtime. Use `fatalHealth()` for frozen bounded counters and status, or `discardPendingFatalRecord()` for an explicit rollback discard. The Node ESM and CommonJS entries never import React Native; non-React-Native callers must inject `fatalStore` explicitly.
 
-Automatic events exclude the original error message, raw stack, arbitrary metadata, full URLs, hosts, query strings, local absolute paths, payloads, and native error text. `onDiagnostic` receives only a fixed code. This integration does not claim mathematically exactly-once delivery, backend-visible deduplication, native crash capture, ANR or hang detection, general offline queueing, or symbolication.
+Automatic events exclude the original error message, raw stack, arbitrary metadata, full URLs, hosts, query strings, local absolute paths, payloads, and native error text. `onDiagnostic` receives only a fixed code. This error-handler integration does not claim mathematically exactly-once delivery, native crash capture, ANR or hang detection, general offline queueing by the fatal-record slot, or symbolication. The client-level persistent queue above owns normal event restart delivery.
 
 ### Opt-in Hermes Promise rejection tracking
 

package/android/src/main/java/co/logbrew/reactnative/EventRecordStore.java

@@ -0,0 +1,611 @@
+package co.logbrew.reactnative;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.zip.CRC32;
+
+/** Crash-safe app-private queue backing the synchronous React Native eventStore adapter. */
+final class EventRecordStore {
+  static final String EVENT_PREFIX = "event-";
+  static final String EVENT_SUFFIX = ".record";
+  static final String MARKER_PREFIX = "accepted-";
+  static final String MARKER_SUFFIX = ".marker";
+
+  private static final int RECORD_MAGIC = 0x4c425145;
+  private static final int MARKER_MAGIC = 0x4c42514d;
+  private static final int FILE_FORMAT_VERSION = 1;
+  private static final int MAX_EVENT_BYTES = 4 * 1024 * 1024;
+  private static final int MAX_QUEUE_BYTES = 4 * 1024 * 1024;
+  private static final int MAX_QUEUE_RECORDS = 1000;
+  private static final Pattern EVENT_PATTERN =
+      Pattern.compile("^event-([0-9]{20})\\.record$");
+  private static final Pattern MARKER_PATTERN =
+      Pattern.compile("^accepted-([0-9]{20})\\.marker$");
+  private static final FatalRecordStore.ParentDirectorySync UNSUPPORTED_PARENT_DIRECTORY_SYNC =
+      directory -> FatalRecordStore.ParentDirectorySyncResult.UNSUPPORTED;
+
+  private final File directory;
+  private final FatalRecordStore.ParentDirectorySync parentDirectorySync;
+  private boolean poisoned;
+
+  EventRecordStore(File directory) {
+    this(directory, UNSUPPORTED_PARENT_DIRECTORY_SYNC);
+  }
+
+  EventRecordStore(
+      File directory, FatalRecordStore.ParentDirectorySync parentDirectorySync) {
+    this.directory = resolveCanonicalParent(directory);
+    this.parentDirectorySync = parentDirectorySync;
+  }
+
+  synchronized Result load() {
+    Snapshot snapshot = snapshot();
+    return snapshot == null
+        ? Result.status("storage_error")
+        : new Result("loaded", snapshot.records);
+  }
+
+  synchronized Result append(String serializedEvent, int eventBytes) {
+    if (poisoned || !validEvent(serializedEvent, eventBytes)) {
+      return Result.status("storage_error");
+    }
+    Snapshot snapshot = snapshot();
+    if (snapshot == null
+        || snapshot.records.size() >= MAX_QUEUE_RECORDS
+        || snapshot.totalEventBytes + (long) eventBytes > MAX_QUEUE_BYTES) {
+      return Result.status("storage_error");
+    }
+    long sequence = Math.max(snapshot.markerSequence, snapshot.maximumRecordSequence);
+    if (sequence == Long.MAX_VALUE) {
+      return Result.status("storage_error");
+    }
+    sequence += 1;
+    File recordFile = new File(directory, eventFileName(sequence));
+    if (!atomicWrite(recordFile, encodeRecord(sequence, serializedEvent, eventBytes))) {
+      return Result.status("storage_error");
+    }
+    return Result.status("appended");
+  }
+
+  synchronized Result acknowledge(int count) {
+    if (poisoned || count < 0) {
+      return Result.status("storage_error");
+    }
+    Snapshot snapshot = snapshot();
+    if (snapshot == null || count > snapshot.records.size()) {
+      return Result.status("storage_error");
+    }
+    if (count == 0) {
+      return Result.status("acknowledged");
+    }
+    long acceptedSequence = snapshot.records.get(count - 1).sequence;
+    if (!commitMarker(acceptedSequence)) {
+      return Result.status("storage_error");
+    }
+    removeAcceptedFiles(acceptedSequence);
+    return Result.status("acknowledged");
+  }
+
+  synchronized Result purge() {
+    if (poisoned || !prepareDirectory() || !removeStaleTemporaryFiles()) {
+      return Result.status("storage_error");
+    }
+    File[] files = directory.listFiles();
+    if (files == null) {
+      return Result.status("storage_error");
+    }
+    long maximumSequence = 0;
+    for (File file : files) {
+      Matcher eventMatcher = EVENT_PATTERN.matcher(file.getName());
+      Matcher markerMatcher = MARKER_PATTERN.matcher(file.getName());
+      Matcher matcher = eventMatcher.matches() ? eventMatcher : markerMatcher.matches() ? markerMatcher : null;
+      if (matcher == null || !isSafeRegularFile(file)) {
+        return Result.status("storage_error");
+      }
+      Long sequence = parseSequence(matcher.group(1));
+      if (sequence == null) {
+        return Result.status("storage_error");
+      }
+      maximumSequence = Math.max(maximumSequence, sequence);
+    }
+    if (maximumSequence == 0) {
+      return Result.status("purged");
+    }
+    if (maximumSequence == Long.MAX_VALUE) {
+      return Result.status("storage_error");
+    }
+    long acceptedSequence = maximumSequence + 1;
+    if (!commitMarker(acceptedSequence)) {
+      return Result.status("storage_error");
+    }
+    removeAcceptedFiles(acceptedSequence);
+    removeAllOlderMarkers(acceptedSequence);
+    return Result.status("purged");
+  }
+
+  synchronized Result close() {
+    return Result.status(poisoned ? "storage_error" : "closed");
+  }
+
+  private Snapshot snapshot() {
+    if (poisoned || !prepareDirectory() || !removeStaleTemporaryFiles()) {
+      return null;
+    }
+    File[] files = directory.listFiles();
+    if (files == null) {
+      return null;
+    }
+
+    long markerSequence = 0;
+    List<FileSequence> eventFiles = new ArrayList<>();
+    List<FileSequence> markerFiles = new ArrayList<>();
+    for (File file : files) {
+      String name = file.getName();
+      Matcher eventMatcher = EVENT_PATTERN.matcher(name);
+      Matcher markerMatcher = MARKER_PATTERN.matcher(name);
+      if (eventMatcher.matches()) {
+        Long sequence = parseSequence(eventMatcher.group(1));
+        if (sequence == null || !isSafeRegularFile(file)) {
+          return null;
+        }
+        eventFiles.add(new FileSequence(file, sequence));
+      } else if (markerMatcher.matches()) {
+        Long sequence = parseSequence(markerMatcher.group(1));
+        if (sequence == null || !isSafeRegularFile(file)) {
+          return null;
+        }
+        markerSequence = Math.max(markerSequence, sequence);
+        markerFiles.add(new FileSequence(file, sequence));
+      } else {
+        return null;
+      }
+    }
+    if (markerSequence > 0) {
+      File newestMarker = new File(directory, markerFileName(markerSequence));
+      if (!isSafeRegularFile(newestMarker) || !validMarker(newestMarker, markerSequence)) {
+        return null;
+      }
+    }
+
+    eventFiles.sort(Comparator.comparingLong(value -> value.sequence));
+    List<Record> records = new ArrayList<>();
+    long totalEventBytes = 0;
+    long maximumRecordSequence = 0;
+    for (FileSequence value : eventFiles) {
+      maximumRecordSequence = Math.max(maximumRecordSequence, value.sequence);
+      if (value.sequence <= markerSequence) {
+        continue;
+      }
+      Record record = decodeRecord(value.file, value.sequence);
+      if (record == null) {
+        return null;
+      }
+      totalEventBytes += record.eventBytes;
+      if (records.size() >= MAX_QUEUE_RECORDS || totalEventBytes > MAX_QUEUE_BYTES) {
+        return null;
+      }
+      records.add(record);
+    }
+
+    removeAcceptedFiles(markerSequence);
+    removeOldMarkers(markerFiles, markerSequence);
+    return new Snapshot(
+        markerSequence, maximumRecordSequence, totalEventBytes, records);
+  }
+
+  private boolean commitMarker(long sequence) {
+    File marker = new File(directory, markerFileName(sequence));
+    if (marker.exists()) {
+      return isSafeRegularFile(marker) && validMarker(marker, sequence);
+    }
+    return atomicWrite(marker, encodeMarker(sequence));
+  }
+
+  private void removeAcceptedFiles(long markerSequence) {
+    if (markerSequence <= 0) {
+      return;
+    }
+    File[] files = directory.listFiles();
+    if (files == null) {
+      return;
+    }
+    boolean deleted = false;
+    for (File file : files) {
+      Matcher matcher = EVENT_PATTERN.matcher(file.getName());
+      if (!matcher.matches()) {
+        continue;
+      }
+      Long sequence = parseSequence(matcher.group(1));
+      if (sequence != null
+          && sequence <= markerSequence
+          && isSafeRegularFile(file)
+          && file.delete()) {
+        deleted = true;
+      }
+    }
+    if (deleted) {
+      parentDirectorySync.sync(directory);
+    }
+  }
+
+  private void removeOldMarkers(List<FileSequence> markers, long markerSequence) {
+    boolean deleted = false;
+    for (FileSequence marker : markers) {
+      if (marker.sequence < markerSequence
+          && isSafeRegularFile(marker.file)
+          && marker.file.delete()) {
+        deleted = true;
+      }
+    }
+    if (deleted) {
+      parentDirectorySync.sync(directory);
+    }
+  }
+
+  private void removeAllOlderMarkers(long markerSequence) {
+    File[] files = directory.listFiles();
+    if (files == null) {
+      return;
+    }
+    List<FileSequence> markers = new ArrayList<>();
+    for (File file : files) {
+      Matcher matcher = MARKER_PATTERN.matcher(file.getName());
+      if (!matcher.matches()) {
+        continue;
+      }
+      Long sequence = parseSequence(matcher.group(1));
+      if (sequence != null) {
+        markers.add(new FileSequence(file, sequence));
+      }
+    }
+    removeOldMarkers(markers, markerSequence);
+  }
+
+  private boolean prepareDirectory() {
+    try {
+      if (directory.exists()) {
+        if (!directory.isDirectory() || !isCanonicalPath(directory)) {
+          return false;
+        }
+      } else if (!directory.mkdirs()) {
+        return false;
+      }
+      return makeDirectoryPrivate(directory) && isCanonicalPath(directory);
+    } catch (IOException | SecurityException error) {
+      return false;
+    }
+  }
+
+  private boolean removeStaleTemporaryFiles() {
+    File[] files = directory.listFiles((unused, name) -> name.endsWith(".tmp"));
+    if (files == null) {
+      return false;
+    }
+    for (File file : files) {
+      if (!isSafeRegularFile(file) || !file.delete()) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  private boolean atomicWrite(File destination, byte[] bytes) {
+    if (bytes == null || bytes.length == 0 || destination.exists()) {
+      return false;
+    }
+    File temporary = new File(directory, destination.getName() + ".tmp");
+    if (temporary.exists()
+        && (!isSafeRegularFile(temporary) || !temporary.delete())) {
+      return false;
+    }
+    boolean committed = false;
+    boolean renamed = false;
+    try {
+      if (!temporary.createNewFile()
+          || !isSafeRegularFile(temporary)
+          || !makeFilePrivate(temporary)) {
+        return false;
+      }
+      try (FileOutputStream output = new FileOutputStream(temporary, false)) {
+        output.write(bytes);
+        output.flush();
+        output.getFD().sync();
+      }
+      if (!makeFilePrivate(temporary) || !temporary.renameTo(destination)) {
+        return false;
+      }
+      renamed = true;
+      if (!makeFilePrivate(destination)) {
+        return false;
+      }
+      if (parentDirectorySync.sync(directory)
+          == FatalRecordStore.ParentDirectorySyncResult.FAILED) {
+        poisoned = true;
+        return false;
+      }
+      committed = true;
+      return true;
+    } catch (IOException | SecurityException error) {
+      return false;
+    } finally {
+      if (!committed) {
+        if (renamed) {
+          poisoned = true;
+        } else if (temporary.exists() && isSafeRegularFile(temporary)) {
+          temporary.delete();
+        }
+      }
+    }
+  }
+
+  private static boolean validEvent(String serializedEvent, int eventBytes) {
+    if (serializedEvent == null || serializedEvent.isEmpty() || eventBytes <= 0) {
+      return false;
+    }
+    byte[] bytes = serializedEvent.getBytes(StandardCharsets.UTF_8);
+    return bytes.length == eventBytes && bytes.length <= MAX_EVENT_BYTES;
+  }
+
+  private static byte[] encodeRecord(
+      long sequence, String serializedEvent, int eventBytes) {
+    byte[] payload = serializedEvent.getBytes(StandardCharsets.UTF_8);
+    CRC32 checksum = new CRC32();
+    checksum.update(payload);
+    try {
+      ByteArrayOutputStream bytes = new ByteArrayOutputStream(payload.length + 32);
+      try (DataOutputStream output = new DataOutputStream(bytes)) {
+        output.writeInt(RECORD_MAGIC);
+        output.writeInt(FILE_FORMAT_VERSION);
+        output.writeLong(sequence);
+        output.writeInt(eventBytes);
+        output.writeInt(payload.length);
+        output.write(payload);
+        output.writeLong(checksum.getValue());
+      }
+      return bytes.toByteArray();
+    } catch (IOException impossible) {
+      return null;
+    }
+  }
+
+  private static Record decodeRecord(File file, long expectedSequence) {
+    if (file.length() <= 0 || file.length() > MAX_EVENT_BYTES + 32L) {
+      return null;
+    }
+    byte[] bytes = readBounded(file, MAX_EVENT_BYTES + 32);
+    if (bytes == null) {
+      return null;
+    }
+    try (DataInputStream input = new DataInputStream(new ByteArrayInputStream(bytes))) {
+      if (input.readInt() != RECORD_MAGIC || input.readInt() != FILE_FORMAT_VERSION) {
+        return null;
+      }
+      long sequence = input.readLong();
+      int eventBytes = input.readInt();
+      int payloadLength = input.readInt();
+      if (sequence != expectedSequence
+          || eventBytes <= 0
+          || payloadLength != eventBytes
+          || payloadLength > MAX_EVENT_BYTES) {
+        return null;
+      }
+      byte[] payload = new byte[payloadLength];
+      input.readFully(payload);
+      long expectedChecksum = input.readLong();
+      if (input.read() != -1) {
+        return null;
+      }
+      CRC32 checksum = new CRC32();
+      checksum.update(payload);
+      if (checksum.getValue() != expectedChecksum) {
+        return null;
+      }
+      String serializedEvent = new String(payload, StandardCharsets.UTF_8);
+      if (!validEvent(serializedEvent, eventBytes)) {
+        return null;
+      }
+      return new Record(sequence, serializedEvent, eventBytes);
+    } catch (IOException error) {
+      return null;
+    }
+  }
+
+  private static byte[] encodeMarker(long sequence) {
+    CRC32 checksum = new CRC32();
+    checksum.update(longBytes(sequence));
+    try {
+      ByteArrayOutputStream bytes = new ByteArrayOutputStream(24);
+      try (DataOutputStream output = new DataOutputStream(bytes)) {
+        output.writeInt(MARKER_MAGIC);
+        output.writeInt(FILE_FORMAT_VERSION);
+        output.writeLong(sequence);
+        output.writeLong(checksum.getValue());
+      }
+      return bytes.toByteArray();
+    } catch (IOException impossible) {
+      return null;
+    }
+  }
+
+  private static boolean validMarker(File file, long expectedSequence) {
+    byte[] bytes = readBounded(file, 24);
+    if (bytes == null || bytes.length != 24) {
+      return false;
+    }
+    try (DataInputStream input = new DataInputStream(new ByteArrayInputStream(bytes))) {
+      if (input.readInt() != MARKER_MAGIC || input.readInt() != FILE_FORMAT_VERSION) {
+        return false;
+      }
+      long sequence = input.readLong();
+      long expectedChecksum = input.readLong();
+      CRC32 checksum = new CRC32();
+      checksum.update(longBytes(sequence));
+      return sequence == expectedSequence
+          && sequence > 0
+          && checksum.getValue() == expectedChecksum
+          && input.read() == -1;
+    } catch (IOException error) {
+      return false;
+    }
+  }
+
+  private static byte[] longBytes(long value) {
+    return new byte[] {
+      (byte) (value >>> 56),
+      (byte) (value >>> 48),
+      (byte) (value >>> 40),
+      (byte) (value >>> 32),
+      (byte) (value >>> 24),
+      (byte) (value >>> 16),
+      (byte) (value >>> 8),
+      (byte) value
+    };
+  }
+
+  private static byte[] readBounded(File file, int maximumBytes) {
+    try (FileInputStream input = new FileInputStream(file);
+        ByteArrayOutputStream output = new ByteArrayOutputStream()) {
+      byte[] buffer = new byte[8192];
+      int total = 0;
+      int count;
+      while ((count = input.read(buffer)) != -1) {
+        total += count;
+        if (total > maximumBytes) {
+          return null;
+        }
+        output.write(buffer, 0, count);
+      }
+      return output.toByteArray();
+    } catch (IOException error) {
+      return null;
+    }
+  }
+
+  private static String eventFileName(long sequence) {
+    return String.format(java.util.Locale.ROOT, "%s%020d%s", EVENT_PREFIX, sequence, EVENT_SUFFIX);
+  }
+
+  private static String markerFileName(long sequence) {
+    return String.format(
+        java.util.Locale.ROOT, "%s%020d%s", MARKER_PREFIX, sequence, MARKER_SUFFIX);
+  }
+
+  private static Long parseSequence(String value) {
+    try {
+      long sequence = Long.parseLong(value);
+      return sequence > 0 ? sequence : null;
+    } catch (NumberFormatException error) {
+      return null;
+    }
+  }
+
+  private static File resolveCanonicalParent(File value) {
+    File absolute = value.getAbsoluteFile();
+    File parent = absolute.getParentFile();
+    if (parent == null) {
+      return absolute;
+    }
+    try {
+      return new File(parent.getCanonicalFile(), absolute.getName());
+    } catch (IOException | SecurityException error) {
+      return absolute;
+    }
+  }
+
+  private static boolean isCanonicalPath(File value) throws IOException {
+    return value.getCanonicalFile().equals(value.getAbsoluteFile());
+  }
+
+  private static boolean isSafeRegularFile(File value) {
+    try {
+      return value.isFile()
+          && isCanonicalPath(value);
+    } catch (IOException | SecurityException error) {
+      return false;
+    }
+  }
+
+  private static boolean makeDirectoryPrivate(File value) {
+    return value.setReadable(false, false)
+        && value.setWritable(false, false)
+        && value.setExecutable(false, false)
+        && value.setReadable(true, true)
+        && value.setWritable(true, true)
+        && value.setExecutable(true, true);
+  }
+
+  private static boolean makeFilePrivate(File value) {
+    return value.setReadable(false, false)
+        && value.setWritable(false, false)
+        && value.setExecutable(false, false)
+        && value.setReadable(true, true)
+        && value.setWritable(true, true);
+  }
+
+  static final class Record {
+    final long sequence;
+    final String serializedEvent;
+    final int eventBytes;
+
+    Record(long sequence, String serializedEvent, int eventBytes) {
+      this.sequence = sequence;
+      this.serializedEvent = serializedEvent;
+      this.eventBytes = eventBytes;
+    }
+  }
+
+  static final class Result {
+    final String status;
+    final List<Record> records;
+
+    Result(String status, List<Record> records) {
+      this.status = status;
+      this.records = Collections.unmodifiableList(new ArrayList<>(records));
+    }
+
+    static Result status(String status) {
+      return new Result(status, Collections.emptyList());
+    }
+  }
+
+  private static final class Snapshot {
+    final long markerSequence;
+    final long maximumRecordSequence;
+    final long totalEventBytes;
+    final List<Record> records;
+
+    Snapshot(
+        long markerSequence,
+        long maximumRecordSequence,
+        long totalEventBytes,
+        List<Record> records) {
+      this.markerSequence = markerSequence;
+      this.maximumRecordSequence = maximumRecordSequence;
+      this.totalEventBytes = totalEventBytes;
+      this.records = records;
+    }
+  }
+
+  private static final class FileSequence {
+    final File file;
+    final long sequence;
+
+    FileSequence(File file, long sequence) {
+      this.file = file;
+      this.sequence = sequence;
+    }
+  }
+}