feat(core): bind semantic node targets to business actions

CHANGELOG.md

@@ -4,6 +4,8 @@ All notable changes to OriginWeave are documented in this file. The format follo
 
 ## [Unreleased]
 
+- Preserve current-node action safeguards while adopting connection-bound field-value replies; a matching reply still does not authorize an action.
+
 - Reject field-value replies received on a replacement connection, even when their request identifier and text match.
 
 - Reject field-observation requests on another browser session and preserve pending requests only when a write may have reached the peer.
@@ -59,6 +61,7 @@ All notable changes to OriginWeave are documented in this file. The format follo
 
 ### Added
 
+- Complete typed semantic-node action retention at the public binding boundary, including fail-closed coverage of registry-authority corruption and deterministic typed error sources.
 - Typed WebDriver BiDi command-family correlation for text-value post-condition observations, so a matching numeric response id cannot consume an outstanding command from another operation family; successful envelopes reuse the parser-proven non-null id invariant without an unreachable fallback branch.
 - Deterministic WebDriver BiDi primary-button click serialization for an already admitted remote node: it emits one fixed `input.performActions` mouse sequence from bounded command/context/node identifiers and remains inert until a trusted adapter binds it to current session, origin, document, policy, and approval authority.
 - Typed outbound WebDriver BiDi primary-button click transport over the bounded client WebSocket stream: it rejects invalid frame deadlines before correlation registration, retires only the just-registered id when local frame preflight proves no command bytes were emitted, preserves correlation across ambiguous writes, and does not treat frame-write success as proof that the browser performed the click.

Cargo.toml

@@ -21,6 +21,7 @@ homepage = "https://github.com/ContextualWisdomLab/OriginWeave"
 
 [workspace.lints.rust]
 unsafe_code = "forbid"
+unexpected_cfgs = { level = "warn", check-cfg = ['cfg(coverage)'] }
 
 [workspace.lints.clippy]
 dbg_macro = "deny"

crates/originweave-core/src/browser_authority_registry.rs

@@ -1,11 +1,13 @@
 use std::collections::BTreeMap;
+use std::error::Error;
+use std::fmt::{Display, Formatter};
 use std::ops::Deref;
 use std::sync::Arc;
 
 use crate::browser_registry::BrowserAuthorityRegistry as RawBrowserAuthorityRegistry;
 use crate::{
-    BrowserRegistryError, BrowserSessionId, BrowsingContextId, DocumentEpoch, ObservedNodeHandle,
-    Origin,
+    BrowserRegistryError, BrowserSessionId, BrowsingContextId, DocumentEpoch, NodeHandleError,
+    ObservedNodeHandle, Origin,
 };
 
 /// A registry-issued node handle that carries opaque provenance in addition to descriptive node state.
@@ -28,6 +30,52 @@ impl Deref for AdmittedNodeHandle {
     }
 }
 
+/// A fail-closed error while revalidating opaque registry-issued node authority.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum AdmittedNodeAuthorityError {
+    /// The supplied handle was issued by a different registry instance.
+    ForeignRegistry,
+    /// The registry no longer retains this exact admitted node binding.
+    NotAdmitted,
+    /// Current session, context, or canonical-origin authority no longer matches.
+    BrowserAuthority(BrowserRegistryError),
+    /// The handle no longer matches the registry's current document lifetime.
+    NodeHandle(NodeHandleError),
+}
+
+impl Display for AdmittedNodeAuthorityError {
+    fn fmt(&self, formatter: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::ForeignRegistry => formatter
+                .write_str("admitted node was issued by a different browser authority registry"),
+            Self::NotAdmitted => formatter
+                .write_str("admitted node authority is no longer retained by this registry"),
+            Self::BrowserAuthority(error) => {
+                write!(
+                    formatter,
+                    "admitted node browser authority rejected input: {error}"
+                )
+            }
+            Self::NodeHandle(error) => {
+                write!(
+                    formatter,
+                    "admitted node document authority rejected input: {error}"
+                )
+            }
+        }
+    }
+}
+
+impl Error for AdmittedNodeAuthorityError {
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+        match self {
+            Self::BrowserAuthority(error) => Some(error),
+            Self::NodeHandle(error) => Some(error),
+            Self::ForeignRegistry | Self::NotAdmitted => None,
+        }
+    }
+}
+
 /// Public browser-authority registry with raw node minting kept inside the crate.
 ///
 /// Browser-session, browsing-context, document-epoch, and canonical-origin lifecycle operations are
@@ -210,6 +258,44 @@ impl BrowserAuthorityRegistry {
             .require_context_origin(browser_session, browsing_context, origin)
     }
 
+    /// Revalidate one exact registry-issued admitted node before later typed dispatch.
+    ///
+    /// This check preserves opaque registry-instance provenance and verifies that this registry still
+    /// retains the exact admitted node key under the current session, context, origin, and document
+    /// epoch. It deliberately does not validate the adapter-local wire identifier; the final typed
+    /// adapter constructor must still bind the exact `sharedId` immediately before browser I/O.
+    pub fn validate_admitted_node_handle(
+        &self,
+        handle: &AdmittedNodeHandle,
+    ) -> Result<(), AdmittedNodeAuthorityError> {
+        if !Arc::ptr_eq(&self.registry_identity, &handle.registry_instance) {
+            return Err(AdmittedNodeAuthorityError::ForeignRegistry);
+        }
+        if !self
+            .admitted_node_external_identifiers
+            .contains_key(&node_authority_key(&handle.observed))
+        {
+            return Err(AdmittedNodeAuthorityError::NotAdmitted);
+        }
+
+        self.require_context_origin(
+            handle.browser_session(),
+            handle.browsing_context(),
+            handle.origin(),
+        )
+        .map_err(AdmittedNodeAuthorityError::BrowserAuthority)
+        .and_then(|current_epoch| {
+            handle
+                .validate_current(
+                    handle.browser_session(),
+                    handle.browsing_context(),
+                    handle.origin(),
+                    current_epoch,
+                )
+                .map_err(AdmittedNodeAuthorityError::NodeHandle)
+        })
+    }
+
     /// Advance a browsing context to the next document epoch and invalidate old node bindings.
     pub fn advance_document(
         &mut self,
@@ -306,3 +392,37 @@ fn node_authority_key(handle: &ObservedNodeHandle) -> (u64, u64, u64, u64) {
         handle.node_id(),
     )
 }
+
+#[cfg(test)]
+mod tests {
+    use std::error::Error;
+
+    use super::{AdmittedNodeAuthorityError, BrowserAuthorityRegistry};
+    use crate::{BrowserRegistryError, Origin};
+
+    #[test]
+    #[cfg_attr(coverage, coverage(off))]
+    fn admitted_node_revalidation_preserves_broken_registry_authority() -> Result<(), Box<dyn Error>>
+    {
+        let mut registry = BrowserAuthorityRegistry::new();
+        let session = registry.register_session("broken-authority-session")?;
+        let context = registry.register_context(session, "broken-authority-context")?;
+        let origin = Origin::parse("https://example.com").map_err(|error| {
+            std::io::Error::other(format!("fixture origin rejected: {error:?}"))
+        })?;
+        let handle = registry
+            .bind_admitted_nodes(session, context, &origin, &["node"])?
+            .pop()
+            .ok_or("fixture did not bind its node")?;
+        registry.validate_admitted_node_handle(&handle)?;
+        registry.inner.remove_context(context)?;
+
+        assert_eq!(
+            registry.validate_admitted_node_handle(&handle),
+            Err(AdmittedNodeAuthorityError::BrowserAuthority(
+                BrowserRegistryError::UnknownBrowsingContext
+            ))
+        );
+        Ok(())
+    }
+}

crates/originweave-core/src/lib.rs

@@ -1,3 +1,4 @@
+#![cfg_attr(coverage, feature(coverage_attribute))]
 //! Shared security and governance contracts for OriginWeave.
 //!
 //! This crate keeps the long-lived value contracts in `contracts` and the
@@ -45,6 +46,7 @@ mod browser_registry;
 mod browser_registry_coverage;
 mod browser_registry_external_context;
 mod contracts;
+mod semantic_action_binding;
 mod webdriver_bidi_command;
 mod webdriver_bidi_error_code;
 mod webdriver_bidi_pointer_click_authority;
@@ -58,7 +60,8 @@ mod webdriver_bidi_websocket_connect_target;
 mod webdriver_bidi_websocket_endpoint;
 
 pub use browser_authority_registry::{
-    AdmittedNodeHandle, BrowserAuthorityRegistry, BrowserRegistryIdentity,
+    AdmittedNodeAuthorityError, AdmittedNodeHandle, BrowserAuthorityRegistry,
+    BrowserRegistryIdentity,
 };
 pub use browser_protocol::{
     BrowserProtocolAdapterDescriptor, BrowserProtocolCapability,
@@ -88,6 +91,9 @@ pub use browser_registry::{
     UNICODE_PROTOCOL_FORMAT_INJECTION_CHARS,
 };
 pub use contracts::*;
+pub use semantic_action_binding::{
+    NodeActionKind, SemanticNodeActionBinding, SemanticNodeActionBindingError,
+};
 pub use webdriver_bidi_command::{
     CorrelatedWebDriverBiDiLocateNodesResponse, MAX_WEBDRIVER_BIDI_COMMAND_ID,
     ValidatedWebDriverBiDiLocateNodesResponse, WEBDRIVER_BIDI_PERFORM_ACTIONS_METHOD,

crates/originweave-core/src/semantic_action_binding.rs

@@ -0,0 +1,103 @@
+use std::fmt;
+
+use crate::{
+    ActionRequest, AdmittedNodeAuthorityError, AdmittedNodeHandle, BrowserAuthorityRegistry,
+};
+
+/// A node-local typed action retained by an authorized semantic binding.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum NodeActionKind {
+    /// Activate the node using browser-native click semantics.
+    Click,
+    /// Insert bounded non-secret text using browser-native input semantics.
+    TypeText,
+    /// Select one option using browser-native selection semantics.
+    SelectOption,
+    /// Set a checkable control to an explicit checked state.
+    SetChecked,
+    /// Scroll the node into the viewport without activating it.
+    ScrollIntoView,
+}
+
+/// One registry-issued browser node and local node action explicitly paired with the business
+/// action request they would serve.
+///
+/// The binding prevents a caller from independently validating one current browser node, selecting
+/// a different browser-local action at dispatch, and combining that side effect with a separately
+/// authorized business intent. It deliberately does not authorize policy, map the node-local action
+/// to a business risk class, grant a destination, resolve secrets, or execute browser I/O. The later
+/// typed adapter boundary still revalidates registry provenance and the exact admitted wire node
+/// immediately before I/O.
+#[derive(Debug)]
+pub struct SemanticNodeActionBinding {
+    handle: AdmittedNodeHandle,
+    node_action: NodeActionKind,
+    request: ActionRequest,
+}
+
+impl SemanticNodeActionBinding {
+    /// Bind one registry-issued admitted node and exact node-local action to a business request from
+    /// the same source origin.
+    pub fn new(
+        handle: AdmittedNodeHandle,
+        node_action: NodeActionKind,
+        request: ActionRequest,
+    ) -> Result<Self, SemanticNodeActionBindingError> {
+        if handle.origin() != request.source_origin() {
+            return Err(SemanticNodeActionBindingError::SourceOriginMismatch);
+        }
+        Ok(Self {
+            handle,
+            node_action,
+            request,
+        })
+    }
+
+    /// Return the exact registry-issued node retained for later immediate-use authority checks.
+    #[must_use]
+    pub const fn handle(&self) -> &AdmittedNodeHandle {
+        &self.handle
+    }
+
+    /// Return the exact browser-local node action retained with the authorized business intent.
+    #[must_use]
+    pub const fn node_action(&self) -> NodeActionKind {
+        self.node_action
+    }
+
+    /// Return the independently classified business action request.
+    #[must_use]
+    pub const fn request(&self) -> &ActionRequest {
+        &self.request
+    }
+
+    /// Revalidate the exact retained admitted-node authority against the trusted current registry.
+    ///
+    /// This preserves opaque registry-instance provenance and current session/context/origin/document
+    /// state. It does not validate the final adapter-local wire identifier or execute browser I/O;
+    /// the typed adapter command constructor must still perform that immediate-use check.
+    pub fn validate_current(
+        &self,
+        registry: &BrowserAuthorityRegistry,
+    ) -> Result<(), AdmittedNodeAuthorityError> {
+        registry.validate_admitted_node_handle(&self.handle)
+    }
+}
+
+/// A bounded failure to pair admitted browser-node authority with a business action request.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum SemanticNodeActionBindingError {
+    /// The request claims a different source document origin than the admitted node.
+    SourceOriginMismatch,
+}
+
+impl fmt::Display for SemanticNodeActionBindingError {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::SourceOriginMismatch => formatter
+                .write_str("admitted node origin does not match action request source origin"),
+        }
+    }
+}
+
+impl std::error::Error for SemanticNodeActionBindingError {}