Updated explainer

pages/stack/interop/_meta.json

@@ -1,10 +1,11 @@
 {
     "explainer": "Interop explainer",
-    "architecture": "Architecture",
+    "predeploy": "Interop predeploys",
     "devnet": "Interop devnet",
     "supersim": "Supersim Multichain Development Environment",
-    "cross-chain-message": "Anatomy of cross-chain message",
     "message-passing": "Interop message passing",
     "op-supervisor": "OP Supervisor",
-    "assets": "Assets"
+    "assets": "Assets",
+    "connectivity": "Connectivity considerations",
+    "security": "Cross-chain security"
 }

pages/stack/interop/architecture.mdx

@@ -44,7 +44,7 @@ graph LR
 ```
 
 OP-Supervisor holds a database of all the log events of all the chains in the interoperability cluster.
-Every event can potentially initiate a cross domain message, and it is the job of OP-Supervisor to validate that the log event really happened on the source chain.
+Every event can potentially initiate a cross-domain message, and it is the job of OP-Supervisor to validate that the log event really happened on the source chain.
 Additionally, OP-Supervisor reads information from L1's consensus layer to determine the transaction safety of L2 blocks.
 
 ## How messages get from one chain to the other
@@ -72,13 +72,13 @@ sequenceDiagram
     note over dst-geth: Executing Message
 ```
 
-Cross domain messages require two transactions.
+Cross-domain messages require two transactions.
 The first transaction creates an *initiating message* on the source chain.
 The second transaction creates an *executing message* on the destination chain.
 This executing message could result in a contract function being executed on the destination chain.
 
 The initiating message is simply a log event.
-Any log event on any chain that inteoperates with the destination can initiate a cross domain message.
+Any log event on any chain that inteoperates with the destination can initiate a cross-domain message.
 
 The transaction that receives the message on the destination chain calls a contract called [`CrossL2Inbox`](https://specs.optimism.io/interop/predeploys.html#crossl2inbox).
 This call can be at the top level, directly from the externally owned account, or come through a smart contract.

pages/stack/interop/connectivity.mdx

@@ -0,0 +1,31 @@
+---
+title: Connectivity considerations
+lang: en-US
+description: What types of connectivity can we support?
+---
+
+import { Callout } from 'nextra/components'
+import Image from 'next/image'
+
+import { InteropCallout } from '@/components/WipCallout'
+
+<InteropCallout />
+
+# Connectivity considerations
+
+## Interop between chains with non-fungible blockspace
+
+Chains that have *non-fungible blockspace* are chains that have different features - for example, chains that use Plasma for data availability, a custom gas paying token, or have a large execution gas limit. 
+As long as the chain can be fault proven, it can work with Superchain interoperability. 
+However, at the application layer, it is important for chains to have legibility into the type of chain that the message originated from. 
+This ensures that applications do not accept messages from chains they consider not secure enough. 
+See [this discussion](https://github.com/ethereum-optimism/specs/issues/121) for additional thoughts.
+
+When it comes to chains that have different gas limits that are interoperable, it creates a set of transactions that can execute on one chain but not the other. 
+This happens when the transaction consumes more than the gas limit of the smaller chain but less than of the bigger chain. At 2024 usages levels, these sorts of transactions are very rare. 
+In the future, it may be the case that these transactions become more common, it will be up to the chain operators to ensure quality of service for their users.
+
+## Are callback style transactions possible?
+
+If two blocks are being built at the same time with shared knowledge of their contents, it is possible to build blocks where a transaction calls to another chain, does compute and then a transaction calls back with the results. 
+This requires no protocol level changes, it just requires more sophisticated block builder infrastructure.