reactor-effect-native 0.2.0 → 0.3.0-rc.0

package/rust/src/abi.rs

@@ -0,0 +1,258 @@
+//! The constants of the C ABI, mirrored from `include/reactor_effect_native.h`.
+//!
+//! A test parses the header and fails when the two disagree. The host mirrors
+//! them too, in `packages/native/src/_internal/bridge.ts`.
+
+use crate::error::BridgeError;
+use serde::{Serialize, Serializer};
+
+/// The ABI version the header declares. The host refuses any other.
+pub(crate) const ABI_VERSION: u32 = 4;
+
+/// The capacity of `ReactorEffectFailure::message`, in bytes.
+pub(crate) const FAILURE_MESSAGE_BYTES: usize = 1020;
+
+/// The smallest response buffer `reactor_effect_peer_call` accepts.
+pub(crate) const CALL_BUFFER_MIN: usize = 4 * 1024 * 1024;
+
+/// The largest request `reactor_effect_peer_call` accepts.
+pub(crate) const MAX_REQUEST_BYTES: usize = 1024 * 1024;
+
+/// The largest data channel message, in either direction.
+pub(crate) const MAX_MESSAGE_BYTES: usize = 256 * 1024;
+
+/// The most a data channel may hold unsent before a send is refused.
+pub(crate) const MAX_BUFFERED_SEND_BYTES: u64 = 1024 * 1024;
+
+/// What an entry point reports (`enum ReactorEffectStatus`).
+///
+/// Non-negative statuses are outcomes. Negative statuses are failure classes,
+/// closed for this ABI; the host maps each one to its own error type.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(i32)]
+pub(crate) enum Status {
+    Ok = 0,
+    /// A take found its queue empty.
+    Again = 1,
+    /// The required sizes were written and the item stays queued.
+    BufferTooSmall = 2,
+    /// The peer is fenced or shut down.
+    Closed = 3,
+    /// An argument or request was rejected.
+    InvalidInput = -1,
+    /// libwebrtc or the bridge failed in a way it cannot classify.
+    Native = -2,
+    /// A queue, buffer or message bound was exceeded.
+    Overflow = -3,
+    /// The remote peer broke the negotiated contract.
+    Protocol = -4,
+    /// libwebrtc refused to create or apply an SDP.
+    SdpRejected = -5,
+    /// The data channel is not open.
+    ChannelClosed = -6,
+}
+
+impl Status {
+    /// The C `int` an entry point returns for this status.
+    pub(crate) const fn code(self) -> i32 {
+        self as i32
+    }
+}
+
+/// A peer operation run by `reactor_effect_peer_call` (`enum ReactorEffectCall`).
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum Operation {
+    /// Create the connection and its local offer.
+    Prepare = 1,
+    /// Apply the remote answer.
+    Answer = 2,
+    /// Pause or resume a declared track.
+    Direction = 3,
+    /// Cap an outgoing track's send bitrate.
+    MaxBitrate = 4,
+    /// Read WebRTC statistics.
+    Stats = 5,
+    /// Read queue pressure.
+    MediaSnapshot = 6,
+}
+
+impl Operation {
+    const ALL: [Self; 6] = [
+        Self::Prepare,
+        Self::Answer,
+        Self::Direction,
+        Self::MaxBitrate,
+        Self::Stats,
+        Self::MediaSnapshot,
+    ];
+}
+
+impl TryFrom<u32> for Operation {
+    type Error = BridgeError;
+
+    fn try_from(code: u32) -> Result<Self, BridgeError> {
+        Self::ALL
+            .into_iter()
+            .find(|operation| *operation as u32 == code)
+            .ok_or_else(|| BridgeError::invalid("unknown native call operation"))
+    }
+}
+
+/// A data channel the bridge owns (`enum ReactorEffectChannel`).
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum Channel {
+    /// Carries Reactor control messages.
+    Control = 0,
+    /// Carries Reactor data messages.
+    Data = 1,
+}
+
+impl Channel {
+    const ALL: [Self; 2] = [Self::Control, Self::Data];
+
+    /// The channel's SCTP label, which also names it in event headers.
+    pub(crate) const fn label(self) -> &'static str {
+        match self {
+            Self::Control => "control",
+            Self::Data => "data",
+        }
+    }
+}
+
+impl TryFrom<u32> for Channel {
+    type Error = BridgeError;
+
+    fn try_from(code: u32) -> Result<Self, BridgeError> {
+        Self::ALL
+            .into_iter()
+            .find(|channel| *channel as u32 == code)
+            .ok_or_else(|| BridgeError::invalid("unknown data channel"))
+    }
+}
+
+impl Serialize for Channel {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        serializer.serialize_str(self.label())
+    }
+}
+
+/// A readiness bit passed to the host's notify callback (`enum ReactorEffectReady`).
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum Ready {
+    /// The transport event queue received an event.
+    Events = 1,
+    /// The decoded video queue received a frame.
+    Video = 2,
+    /// The decoded audio queue received a block.
+    Audio = 4,
+}
+
+impl Ready {
+    /// This readiness as its bit of the callback's mask.
+    pub(crate) const fn bit(self) -> u32 {
+        self as u32
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::collections::BTreeMap;
+
+    const HEADER: &str = include_str!("../include/reactor_effect_native.h");
+
+    /// Every `REACTOR_EFFECT_<NAME> = <value>` enumerator the header declares.
+    fn header_enumerators() -> BTreeMap<String, i64> {
+        HEADER
+            .lines()
+            .filter_map(|line| {
+                let (name, value) = line
+                    .trim()
+                    .strip_prefix("REACTOR_EFFECT_")?
+                    .split_once(" = ")?;
+                let digits: String = value
+                    .chars()
+                    .take_while(|c| *c == '-' || c.is_ascii_digit())
+                    .collect();
+                Some((name.to_owned(), digits.parse().ok()?))
+            })
+            .collect()
+    }
+
+    #[test]
+    fn the_header_declares_exactly_these_statuses_calls_channels_and_readiness_bits() {
+        let statuses = [
+            ("OK", Status::Ok),
+            ("AGAIN", Status::Again),
+            ("BUFFER_TOO_SMALL", Status::BufferTooSmall),
+            ("CLOSED", Status::Closed),
+            ("INVALID_INPUT", Status::InvalidInput),
+            ("NATIVE", Status::Native),
+            ("OVERFLOW", Status::Overflow),
+            ("PROTOCOL", Status::Protocol),
+            ("SDP_REJECTED", Status::SdpRejected),
+            ("CHANNEL_CLOSED", Status::ChannelClosed),
+        ]
+        .map(|(name, status)| (name, i64::from(status.code())));
+        let calls = [
+            ("PREPARE", Operation::Prepare),
+            ("ANSWER", Operation::Answer),
+            ("DIRECTION", Operation::Direction),
+            ("MAX_BITRATE", Operation::MaxBitrate),
+            ("STATS", Operation::Stats),
+            ("MEDIA_SNAPSHOT", Operation::MediaSnapshot),
+        ]
+        .map(|(name, operation)| (name, i64::from(operation as u32)));
+        let channels = [("CONTROL", Channel::Control), ("DATA", Channel::Data)]
+            .map(|(name, channel)| (name, i64::from(channel as u32)));
+        let ready = [
+            ("READY_EVENTS", Ready::Events),
+            ("READY_VIDEO", Ready::Video),
+            ("READY_AUDIO", Ready::Audio),
+        ]
+        .map(|(name, ready)| (name, i64::from(ready.bit())));
+
+        let expected: BTreeMap<String, i64> = statuses
+            .into_iter()
+            .chain(calls)
+            .chain(channels)
+            .chain(ready)
+            .map(|(name, value)| (name.to_owned(), value))
+            .collect();
+        assert_eq!(header_enumerators(), expected);
+    }
+
+    #[test]
+    fn the_header_declares_this_abi_version_and_failure_capacity() {
+        assert!(HEADER.contains(&format!("/* ABI {ABI_VERSION}.")));
+        assert!(HEADER.contains(&format!("uint8_t message[{FAILURE_MESSAGE_BYTES}];")));
+    }
+
+    #[test]
+    fn every_call_and_channel_code_parses_back_to_its_variant() {
+        for operation in Operation::ALL {
+            assert_eq!(Operation::try_from(operation as u32), Ok(operation));
+        }
+        for channel in Channel::ALL {
+            assert_eq!(Channel::try_from(channel as u32), Ok(channel));
+        }
+    }
+
+    #[test]
+    fn unknown_call_and_channel_codes_are_invalid_input() {
+        for code in [0, 7, u32::MAX] {
+            let error = Operation::try_from(code).unwrap_err();
+            assert_eq!(error, BridgeError::invalid("unknown native call operation"));
+        }
+        for code in [2, u32::MAX] {
+            let error = Channel::try_from(code).unwrap_err();
+            assert_eq!(error, BridgeError::invalid("unknown data channel"));
+        }
+    }
+
+    #[test]
+    fn channels_serialize_as_their_labels() {
+        let labels = serde_json::to_value(Channel::ALL).unwrap();
+        assert_eq!(labels, serde_json::json!(["control", "data"]));
+    }
+}

package/rust/src/error.rs

@@ -0,0 +1,149 @@
+//! Bridge failures and the ABI failure class each one reports.
+
+use crate::abi::Status;
+use std::fmt;
+use std::sync::mpsc::{RecvError, SendError};
+
+/// The failure class of a [`BridgeError`], which fixes the status the C ABI
+/// reports for it.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum FailureClass {
+    Closed,
+    InvalidInput,
+    Native,
+    Overflow,
+    Protocol,
+    SdpRejected,
+    ChannelClosed,
+}
+
+impl FailureClass {
+    /// The status an entry point returns for this class.
+    pub(crate) const fn status(self) -> Status {
+        match self {
+            Self::Closed => Status::Closed,
+            Self::InvalidInput => Status::InvalidInput,
+            Self::Native => Status::Native,
+            Self::Overflow => Status::Overflow,
+            Self::Protocol => Status::Protocol,
+            Self::SdpRejected => Status::SdpRejected,
+            Self::ChannelClosed => Status::ChannelClosed,
+        }
+    }
+}
+
+/// A classified failure. Its message is diagnostic text for the host, which
+/// never matches on it: the class is the failure.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct BridgeError {
+    pub(crate) class: FailureClass,
+    pub(crate) message: String,
+}
+
+impl BridgeError {
+    pub(crate) fn new(class: FailureClass, message: impl Into<String>) -> Self {
+        Self {
+            class,
+            message: message.into(),
+        }
+    }
+
+    pub(crate) fn invalid(message: impl Into<String>) -> Self {
+        Self::new(FailureClass::InvalidInput, message)
+    }
+
+    pub(crate) fn overflow(message: impl Into<String>) -> Self {
+        Self::new(FailureClass::Overflow, message)
+    }
+
+    pub(crate) fn closed() -> Self {
+        Self::new(FailureClass::Closed, "native peer is closed")
+    }
+}
+
+impl fmt::Display for BridgeError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(&self.message)
+    }
+}
+
+impl std::error::Error for BridgeError {}
+
+/// A peer's channels to its owner thread disconnect only once that thread has
+/// stopped, so a failed send or receive means the peer has closed.
+impl<T> From<SendError<T>> for BridgeError {
+    fn from(_: SendError<T>) -> Self {
+        Self::closed()
+    }
+}
+
+impl From<RecvError> for BridgeError {
+    fn from(_: RecvError) -> Self {
+        Self::closed()
+    }
+}
+
+/// Classifies reactor-webrtc failures.
+///
+/// reactor-webrtc reports every libwebrtc failure as an untyped string, so the
+/// class comes from the operation that failed rather than from the error.
+pub(crate) trait Classify<T> {
+    /// Report a failure of `operation` as `class`, keeping libwebrtc's text.
+    fn classify(self, class: FailureClass, operation: &str) -> Result<T, BridgeError>;
+}
+
+impl<T> Classify<T> for reactor_webrtc::Result<T> {
+    fn classify(self, class: FailureClass, operation: &str) -> Result<T, BridgeError> {
+        self.map_err(|error| BridgeError::new(class, format!("{operation}: {error}")))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::mpsc;
+
+    #[test]
+    fn a_classified_failure_names_its_operation_and_keeps_the_libwebrtc_text() {
+        let failed: reactor_webrtc::Result<()> =
+            Err(reactor_webrtc::Error::Webrtc("bad fingerprint".into()));
+        let error = failed
+            .classify(FailureClass::SdpRejected, "set_remote_description")
+            .unwrap_err();
+        assert_eq!(error.class, FailureClass::SdpRejected);
+        assert_eq!(
+            error.message,
+            "set_remote_description: webrtc error: bad fingerprint"
+        );
+    }
+
+    #[test]
+    fn every_failure_class_reports_a_failure_status_except_closed() {
+        let classes = [
+            FailureClass::InvalidInput,
+            FailureClass::Native,
+            FailureClass::Overflow,
+            FailureClass::Protocol,
+            FailureClass::SdpRejected,
+            FailureClass::ChannelClosed,
+        ];
+        for class in classes {
+            assert!(class.status().code() < 0, "{class:?}");
+        }
+        // Closed is an outcome the host expects, not a failure of the call.
+        assert_eq!(FailureClass::Closed.status(), Status::Closed);
+    }
+
+    #[test]
+    fn a_disconnected_owner_channel_reads_as_a_closed_peer() {
+        let (sender, receiver) = mpsc::channel::<()>();
+        drop(receiver);
+        let unsent = sender.send(()).unwrap_err();
+        assert_eq!(BridgeError::from(unsent), BridgeError::closed());
+
+        let (sender, receiver) = mpsc::channel::<()>();
+        drop(sender);
+        let unreceived = receiver.recv().unwrap_err();
+        assert_eq!(BridgeError::from(unreceived), BridgeError::closed());
+    }
+}

package/rust/src/ffi/memory.rs

@@ -0,0 +1,256 @@
+//! Views of caller memory.
+//!
+//! An entry point creates each view, unsafely, from one pointer argument
+//! under the clause of its contract that covers that pointer. Using a view is
+//! then safe. Output views write through raw pointers and never form
+//! references, since caller memory may be uninitialized.
+//!
+//! A misaligned pointer, or a length over its bound, is refused before any
+//! caller memory is touched: no valid caller passes one, and using it would be
+//! undefined behavior.
+
+use crate::error::{BridgeError, FailureClass};
+use crate::peer::ReactorEffectPeer;
+use std::any::type_name;
+use std::ptr::{self, NonNull};
+use std::slice;
+
+/// Caller memory for one `T`.
+pub(super) struct Out<T>(NonNull<T>);
+
+impl<T> Out<T> {
+    /// A view of `ptr`, or `None` when it is null.
+    ///
+    /// # Errors
+    /// Invalid input when `ptr` is not aligned for `T`.
+    ///
+    /// # Safety
+    /// A non-null, aligned `ptr` must be valid for writes of one `T` until the
+    /// entry point returns.
+    pub(super) unsafe fn new(ptr: *mut T) -> Result<Option<Self>, BridgeError> {
+        aligned(ptr)?;
+        Ok(NonNull::new(ptr).map(Self))
+    }
+
+    pub(super) fn write(&mut self, value: T) {
+        // SAFETY: `new`'s caller made the location writable until the entry
+        // point returns, and views never outlive their entry point.
+        unsafe { self.0.as_ptr().write(value) }
+    }
+}
+
+/// Caller memory for up to `capacity` elements. It may be null when the
+/// caller only asks for the sizes of what is queued.
+pub(super) struct OutSlice<T> {
+    ptr: *mut T,
+    capacity: usize,
+}
+
+impl<T: Copy> OutSlice<T> {
+    /// A view of `capacity` elements at `ptr`, which may be null.
+    ///
+    /// # Errors
+    /// Invalid input when `ptr` is not aligned for `T`.
+    ///
+    /// # Safety
+    /// A non-null, aligned `ptr` must be valid for writes of `capacity`
+    /// elements until the entry point returns.
+    pub(super) unsafe fn new(ptr: *mut T, capacity: usize) -> Result<Self, BridgeError> {
+        aligned(ptr)?;
+        Ok(Self { ptr, capacity })
+    }
+
+    pub(super) fn is_null(&self) -> bool {
+        self.ptr.is_null()
+    }
+
+    /// Whether `len` elements fit.
+    pub(super) fn holds(&self, len: usize) -> bool {
+        len <= self.capacity && (len == 0 || !self.ptr.is_null())
+    }
+
+    /// Copy `items` to the start of the buffer.
+    ///
+    /// # Errors
+    /// A native failure, copying nothing, if the buffer cannot hold them.
+    /// Callers rule that out with [`holds`](Self::holds) first.
+    pub(super) fn copy_from(&mut self, items: &[T]) -> Result<(), BridgeError> {
+        if !self.holds(items.len()) {
+            return Err(BridgeError::new(
+                FailureClass::Native,
+                "the caller's buffer cannot hold the item",
+            ));
+        }
+        if !items.is_empty() {
+            // SAFETY: `holds` shows the buffer is non-null with room for
+            // `items`, `new`'s caller made it writable, and caller memory
+            // cannot overlap the bridge-owned `items`.
+            unsafe { ptr::copy_nonoverlapping(items.as_ptr(), self.ptr, items.len()) }
+        }
+        Ok(())
+    }
+}
+
+/// Borrow `len` bytes of caller memory, refusing more than `max` before
+/// reading any. A zero length needs no pointer.
+///
+/// # Errors
+/// Overflow when `len` exceeds `max`, and invalid input for a null `data`
+/// with a nonzero length.
+///
+/// # Safety
+/// When `len` is nonzero and at most `max`, and `data` is non-null, `data`
+/// must be valid for reads of `len` bytes that nothing writes until the entry
+/// point returns.
+pub(super) unsafe fn input<'call>(
+    data: *const u8,
+    len: usize,
+    max: usize,
+) -> Result<&'call [u8], BridgeError> {
+    if len > max {
+        return Err(BridgeError::overflow(format!(
+            "input of {len} bytes exceeds its {max}-byte bound"
+        )));
+    }
+    if len == 0 {
+        return Ok(&[]);
+    }
+    if data.is_null() {
+        return Err(BridgeError::invalid("null input with a nonzero length"));
+    }
+    // SAFETY: the caller made `data` valid for reads of `len` bytes, unchanged
+    // for the call.
+    Ok(unsafe { slice::from_raw_parts(data, len) })
+}
+
+/// Borrow the peer behind a handle.
+///
+/// # Errors
+/// Invalid input for a null or misaligned handle.
+///
+/// # Safety
+/// An aligned, non-null `peer` must be a handle from
+/// `reactor_effect_peer_create` that stays undestroyed until the entry point
+/// returns.
+pub(super) unsafe fn peer_ref<'call>(
+    peer: *mut ReactorEffectPeer,
+) -> Result<&'call ReactorEffectPeer, BridgeError> {
+    aligned(peer)?;
+    // SAFETY: a non-null, aligned `peer` is a live `Box::into_raw` pointer for
+    // the call, per the caller.
+    unsafe { peer.as_ref() }.ok_or_else(|| BridgeError::invalid("null native peer handle"))
+}
+
+/// Refuse a pointer that is not aligned for `T`. A null pointer is aligned.
+fn aligned<T>(ptr: *const T) -> Result<(), BridgeError> {
+    if ptr.is_aligned() {
+        return Ok(());
+    }
+    let name = type_name::<T>().rsplit("::").next().unwrap_or_default();
+    Err(BridgeError::invalid(format!("misaligned {name} pointer")))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn a_slice_view_holds_what_fits_and_null_holds_only_nothing() {
+        let mut buffer = [0u8; 4];
+        // SAFETY: `buffer` is writable for 4 bytes for the whole test.
+        let view = unsafe { OutSlice::new(buffer.as_mut_ptr(), buffer.len()) }.unwrap();
+        assert!(view.holds(0) && view.holds(4) && !view.holds(5));
+        // SAFETY: a null view is never written.
+        let null = unsafe { OutSlice::<u8>::new(ptr::null_mut(), 8) }.unwrap();
+        assert!(null.is_null());
+        assert!(null.holds(0) && !null.holds(1));
+    }
+
+    #[test]
+    fn a_slice_view_copies_to_its_start() {
+        let mut buffer = [9u8; 4];
+        // SAFETY: `buffer` is writable for 4 bytes for the whole test.
+        let mut view = unsafe { OutSlice::new(buffer.as_mut_ptr(), buffer.len()) }.unwrap();
+        assert_eq!(view.copy_from(&[1, 2]), Ok(()));
+        assert_eq!(view.copy_from(&[]), Ok(()));
+        assert_eq!(buffer, [1, 2, 9, 9]);
+    }
+
+    #[test]
+    fn a_slice_view_refuses_an_item_it_cannot_hold_and_copies_nothing() {
+        let mut buffer = [0u8; 1];
+        // SAFETY: `buffer` is writable for 1 byte for the whole test.
+        let mut view = unsafe { OutSlice::new(buffer.as_mut_ptr(), buffer.len()) }.unwrap();
+        let error = view.copy_from(&[1, 2]).unwrap_err();
+        assert_eq!(error.class, FailureClass::Native);
+        // SAFETY: a null view is never written.
+        let mut null = unsafe { OutSlice::<u8>::new(ptr::null_mut(), 8) }.unwrap();
+        assert_eq!(
+            null.copy_from(&[1]).unwrap_err().class,
+            FailureClass::Native
+        );
+        assert_eq!(null.copy_from(&[]), Ok(()));
+        assert_eq!(buffer, [0]);
+    }
+
+    #[test]
+    fn input_needs_a_pointer_only_for_bytes() {
+        // SAFETY: a zero length reads nothing.
+        let empty = unsafe { input(ptr::null(), 0, 8) };
+        assert_eq!(empty, Ok(&[][..]));
+        // SAFETY: a null pointer is rejected before any read.
+        let null = unsafe { input(ptr::null(), 3, 8) };
+        assert_eq!(
+            null,
+            Err(BridgeError::invalid("null input with a nonzero length"))
+        );
+        let bytes = [1, 2, 3];
+        // SAFETY: `bytes` is readable for its length for the whole test.
+        let read = unsafe { input(bytes.as_ptr(), bytes.len(), 3) };
+        assert_eq!(read, Ok(&bytes[..]));
+    }
+
+    #[test]
+    fn input_refuses_a_length_over_its_bound_before_reading() {
+        // SAFETY: nothing is readable behind a dangling pointer, and a length
+        // over the bound is refused before any read.
+        let over = unsafe { input(NonNull::dangling().as_ptr(), 9, 8) };
+        assert_eq!(over.unwrap_err().class, FailureClass::Overflow);
+    }
+
+    #[test]
+    fn views_refuse_misaligned_pointers_and_accept_null() {
+        let mut words = [0u32; 2];
+        #[expect(
+            clippy::cast_ptr_alignment,
+            reason = "the test needs a misaligned pointer"
+        )]
+        let misaligned = words
+            .as_mut_ptr()
+            .cast::<u8>()
+            .wrapping_add(1)
+            .cast::<u32>();
+        // SAFETY: a misaligned pointer is refused before any write.
+        let out = unsafe { Out::new(misaligned) };
+        assert_eq!(
+            out.err(),
+            Some(BridgeError::invalid("misaligned u32 pointer"))
+        );
+        // SAFETY: as above.
+        let slice = unsafe { OutSlice::new(misaligned, 1) };
+        assert_eq!(
+            slice.err().map(|error| error.class),
+            Some(FailureClass::InvalidInput)
+        );
+        // SAFETY: a null view is never written.
+        let null = unsafe { Out::<u32>::new(ptr::null_mut()) };
+        assert!(matches!(null, Ok(None)));
+        // SAFETY: a misaligned handle is refused before it is dereferenced.
+        let handle = unsafe { peer_ref(misaligned.cast()) };
+        assert_eq!(
+            handle.err().map(|error| error.class),
+            Some(FailureClass::InvalidInput)
+        );
+        assert_eq!(words, [0, 0]);
+    }
+}