feat(core): bind browser operations to exact protocol capabilities

CHANGELOG.md

@@ -13,6 +13,9 @@ All notable changes to OriginWeave are documented in this file. The format follo
 - Runtime browser-adapter version binding at the atomic protocol-use boundary: the caller-supplied bounded adapter-version token must exactly match the reviewed descriptor version before runtime revision or capability checks can succeed, preventing adapter-build drift from silently reusing otherwise matching protocol/browser metadata without authenticating or attesting the adapter process.
 - Same-call browser-protocol dispatch gating that validates current protocol family, adapter version, pinned protocol/browser revisions, OriginWeave generation, and required capability before invoking one callback, transferring the non-cloneable validation proof by ownership without turning metadata validation into browser or Agent authority.
 - Context-bound browser-protocol dispatch composition that revalidates the exact OriginWeave browser session/context pair, carries the registry's current document epoch into the immediate callback, and separately requires the same exact runtime protocol metadata/capability checks before dispatch without claiming origin, destination, typed-input, transport-authentication, or post-condition authority.
+- Typed browser-protocol operations that derive the exact adapter capability inside the strongest current context/origin/document-epoch dispatch boundary, preventing callers from independently selecting mismatched operation and capability metadata without performing browser I/O or granting policy authority.
+- Bounded WebDriver BiDi accessibility-node query parameters for `browsingContext.locateNodes`, with reviewed selector/result budgets, minimal remote-value serialization options, and fail-closed revalidation that rejects an untrusted adapter response whose returned node count exceeds the exact request budget before node normalization or retention.
+- Fail-closed WebDriver BiDi `script.NodeRemoteValue` admission that requires the exact remote type `node` and a non-empty `sharedId` within the same UTF-8 identifier budget as browser session and context identifiers, so an untrusted `locateNodes` item cannot be retained as a later typed-input handle without a usable shared node identity.
 - Credential-safe browser-protocol validation evidence that copies only the already validated protocol family, OriginWeave generation, adapter version, pinned protocol/browser revisions, and exact capability into cloneable audit metadata without recreating the non-cloneable validation prerequisite or granting browser/Agent authority.
 - Canonical HTTPS and loopback-origin boundary with case-normalized schemes and hosts, default-port normalization, IPv4/IPv6 handling, browser-special numeric-host rejection, and explicit malformed-input errors.
 - Typed browser actions, capabilities, risk classes, execution modes, robots decisions, secret-delivery contracts, immutable canonical action-intent digests, and intent-bound approval scopes.

crates/originweave-core/src/lib.rs

@@ -10,6 +10,7 @@
 
 mod browser_protocol;
 mod browser_protocol_dispatch;
+mod browser_protocol_operation;
 mod browser_registry;
 #[cfg(test)]
 mod browser_registry_coverage;
@@ -27,6 +28,15 @@ pub use browser_protocol_dispatch::{
     BrowserContextOriginEpochDispatchTarget, BrowserContextProtocolDispatchError,
     BrowserProtocolRuntimeMetadata,
 };
+pub use browser_protocol_operation::{
+    BrowserProtocolOperation, MAX_BROWSER_ACCESSIBILITY_QUERY_NAME_BYTES,
+    MAX_BROWSER_ACCESSIBILITY_QUERY_NODE_COUNT, MAX_BROWSER_ACCESSIBILITY_QUERY_ROLE_BYTES,
+    WEBDRIVER_BIDI_LOCATE_NODES_METHOD, WEBDRIVER_BIDI_NODE_REMOTE_VALUE_TYPE,
+    WEBDRIVER_BIDI_QUERY_INCLUDE_SHADOW_TREE, WEBDRIVER_BIDI_QUERY_MAX_DOM_DEPTH,
+    WEBDRIVER_BIDI_QUERY_MAX_OBJECT_DEPTH, WebDriverBiDiAccessibilityQuery,
+    WebDriverBiDiAccessibilityQueryError, WebDriverBiDiRemoteNodeReference,
+    WebDriverBiDiRemoteNodeReferenceError,
+};
 pub use browser_registry::{
     BrowserAuthorityRegistry, BrowserRegistryError, MAX_EXTERNAL_BROWSER_IDENTIFIER_BYTES,
 };

crates/originweave-core/tests/browser_typed_operation_protocol_dispatch.rs

@@ -0,0 +1,150 @@
+use std::{cell::Cell, error::Error, io};
+
+use originweave_core::{
+    BrowserAuthorityRegistry, BrowserContextDispatchTarget, BrowserContextOriginDispatchTarget,
+    BrowserContextOriginEpochDispatchTarget, BrowserContextProtocolDispatchError,
+    BrowserProtocolAdapterDescriptor, BrowserProtocolCapability, BrowserProtocolKind,
+    BrowserProtocolOperation, BrowserProtocolRuntimeMetadata, DocumentEpoch, Origin,
+    OriginWeaveProtocolVersion, ValidatedBrowserProtocolUse,
+};
+
+const ORIGINWEAVE_PROTOCOL_VERSION: OriginWeaveProtocolVersion =
+    OriginWeaveProtocolVersion::new(0, 1);
+const ADAPTER_VERSION: &str = "originweave-bidi-v1";
+const PROTOCOL_REVISION: &str = "webdriver-bidi-wd-2026-06-01";
+const BROWSER_REVISION: &str = "chromium-r1639810";
+
+fn descriptor(
+    capabilities: &[BrowserProtocolCapability],
+) -> Result<BrowserProtocolAdapterDescriptor, Box<dyn Error>> {
+    Ok(BrowserProtocolAdapterDescriptor::new(
+        BrowserProtocolKind::WebDriverBiDi,
+        ORIGINWEAVE_PROTOCOL_VERSION,
+        ADAPTER_VERSION,
+        PROTOCOL_REVISION,
+        BROWSER_REVISION,
+        capabilities,
+    )?)
+}
+
+fn runtime_metadata() -> BrowserProtocolRuntimeMetadata<'static> {
+    BrowserProtocolRuntimeMetadata::new(
+        BrowserProtocolKind::WebDriverBiDi,
+        ADAPTER_VERSION,
+        PROTOCOL_REVISION,
+        BROWSER_REVISION,
+    )
+}
+
+fn origin(value: &str) -> Result<Origin, Box<dyn Error>> {
+    Origin::parse(value).map_err(|_| {
+        Box::new(io::Error::new(
+            io::ErrorKind::InvalidInput,
+            "invalid controlled origin fixture",
+        )) as Box<dyn Error>
+    })
+}
+
+fn typed_input_target<'a>(
+    registry: &mut BrowserAuthorityRegistry,
+    expected_origin: &'a Origin,
+) -> Result<BrowserContextOriginEpochDispatchTarget<'a>, Box<dyn Error>> {
+    let session = registry.register_session("webdriver-session")?;
+    let context = registry.register_context(session, "top-level-context")?;
+    let epoch = registry.bind_context_origin(session, context, expected_origin)?;
+    Ok(BrowserContextOriginEpochDispatchTarget::new(
+        BrowserContextOriginDispatchTarget::new(
+            BrowserContextDispatchTarget::new(session, context),
+            expected_origin,
+        ),
+        epoch,
+    ))
+}
+
+#[test]
+fn buyer_visible_operations_map_to_exact_transport_capabilities() {
+    let expected = [
+        (
+            BrowserProtocolOperation::Navigate,
+            BrowserProtocolCapability::Navigation,
+        ),
+        (
+            BrowserProtocolOperation::QueryNodes,
+            BrowserProtocolCapability::SemanticObservation,
+        ),
+        (
+            BrowserProtocolOperation::ClickNode,
+            BrowserProtocolCapability::TypedInput,
+        ),
+        (
+            BrowserProtocolOperation::TypeText,
+            BrowserProtocolCapability::TypedInput,
+        ),
+        (
+            BrowserProtocolOperation::WaitForState,
+            BrowserProtocolCapability::SemanticObservation,
+        ),
+        (
+            BrowserProtocolOperation::ObserveNetwork,
+            BrowserProtocolCapability::NetworkObservation,
+        ),
+    ];
+
+    for (operation, capability) in expected {
+        assert_eq!(operation.required_capability(), capability);
+    }
+}
+
+#[test]
+fn typed_operation_dispatch_derives_the_required_capability() -> Result<(), Box<dyn Error>> {
+    let descriptor = descriptor(&[BrowserProtocolCapability::TypedInput])?;
+    let mut registry = BrowserAuthorityRegistry::new();
+    let expected_origin = origin("https://app.example")?;
+    let target = typed_input_target(&mut registry, &expected_origin)?;
+
+    let result = descriptor.dispatch_operation_if_context_origin_epoch_current(
+        &registry,
+        target,
+        ORIGINWEAVE_PROTOCOL_VERSION,
+        runtime_metadata(),
+        BrowserProtocolOperation::TypeText,
+        |validated: ValidatedBrowserProtocolUse, operation, epoch: DocumentEpoch| {
+            (operation, validated.capability(), epoch.value())
+        },
+    )?;
+
+    assert_eq!(
+        result,
+        (
+            BrowserProtocolOperation::TypeText,
+            BrowserProtocolCapability::TypedInput,
+            1,
+        )
+    );
+    Ok(())
+}
+
+#[test]
+fn unsupported_typed_operation_fails_before_dispatch_callback() -> Result<(), Box<dyn Error>> {
+    let descriptor = descriptor(&[BrowserProtocolCapability::SemanticObservation])?;
+    let mut registry = BrowserAuthorityRegistry::new();
+    let expected_origin = origin("https://app.example")?;
+    let target = typed_input_target(&mut registry, &expected_origin)?;
+    let dispatch_called = Cell::new(false);
+
+    let result = descriptor.dispatch_operation_if_context_origin_epoch_current(
+        &registry,
+        target,
+        ORIGINWEAVE_PROTOCOL_VERSION,
+        runtime_metadata(),
+        BrowserProtocolOperation::ClickNode,
+        |_validated, _operation, _epoch| dispatch_called.set(true),
+    );
+
+    assert!(matches!(
+        result,
+        Err(BrowserContextProtocolDispatchError::ProtocolValidation(_))
+    ));
+    assert!(!dispatch_called.get());
+    Ok(())
+}

crates/originweave-core/tests/webdriver_bidi_accessibility_query.rs

@@ -0,0 +1,137 @@
+use std::error::Error;
+
+use originweave_core::{
+    MAX_BROWSER_ACCESSIBILITY_QUERY_NAME_BYTES, MAX_BROWSER_ACCESSIBILITY_QUERY_NODE_COUNT,
+    MAX_BROWSER_ACCESSIBILITY_QUERY_ROLE_BYTES, WEBDRIVER_BIDI_LOCATE_NODES_METHOD,
+    WEBDRIVER_BIDI_QUERY_INCLUDE_SHADOW_TREE, WEBDRIVER_BIDI_QUERY_MAX_DOM_DEPTH,
+    WEBDRIVER_BIDI_QUERY_MAX_OBJECT_DEPTH, WebDriverBiDiAccessibilityQuery,
+    WebDriverBiDiAccessibilityQueryError,
+};
+
+#[test]
+fn accessibility_query_exposes_exact_bidi_method_and_locator_contract() -> Result<(), Box<dyn Error>>
+{
+    let query = WebDriverBiDiAccessibilityQuery::new(Some("textbox"), Some("Task text"), 32)?;
+
+    assert_eq!(query.method(), WEBDRIVER_BIDI_LOCATE_NODES_METHOD);
+    assert_eq!(query.method(), "browsingContext.locateNodes");
+    assert_eq!(query.locator_type(), "accessibility");
+    assert_eq!(query.role(), Some("textbox"));
+    assert_eq!(query.name(), Some("Task text"));
+    assert_eq!(query.max_node_count(), 32);
+    Ok(())
+}
+
+#[test]
+fn accessibility_query_fixes_minimal_serialization_options() -> Result<(), Box<dyn Error>> {
+    let query = WebDriverBiDiAccessibilityQuery::new(Some("textbox"), None, 8)?;
+
+    assert_eq!(WEBDRIVER_BIDI_QUERY_MAX_DOM_DEPTH, 0);
+    assert_eq!(WEBDRIVER_BIDI_QUERY_MAX_OBJECT_DEPTH, 0);
+    assert_eq!(WEBDRIVER_BIDI_QUERY_INCLUDE_SHADOW_TREE, "none");
+    assert_eq!(query.serialization_max_dom_depth(), 0);
+    assert_eq!(query.serialization_max_object_depth(), 0);
+    assert_eq!(query.serialization_include_shadow_tree(), "none");
+    Ok(())
+}
+
+#[test]
+fn role_only_and_name_only_queries_are_valid() -> Result<(), Box<dyn Error>> {
+    let role_only = WebDriverBiDiAccessibilityQuery::new(Some("button"), None, 1)?;
+    assert_eq!(role_only.role(), Some("button"));
+    assert_eq!(role_only.name(), None);
+
+    let name_only = WebDriverBiDiAccessibilityQuery::new(None, Some("Submit task"), 1)?;
+    assert_eq!(name_only.role(), None);
+    assert_eq!(name_only.name(), Some("Submit task"));
+    Ok(())
+}
+
+#[test]
+fn missing_or_empty_accessibility_locator_fields_fail_closed() {
+    assert_eq!(
+        WebDriverBiDiAccessibilityQuery::new(None, None, 1),
+        Err(WebDriverBiDiAccessibilityQueryError::MissingLocatorValue)
+    );
+    assert_eq!(
+        WebDriverBiDiAccessibilityQuery::new(Some(""), None, 1),
+        Err(WebDriverBiDiAccessibilityQueryError::EmptyRole)
+    );
+    assert_eq!(
+        WebDriverBiDiAccessibilityQuery::new(None, Some(""), 1),
+        Err(WebDriverBiDiAccessibilityQueryError::EmptyName)
+    );
+}
+
+#[test]
+fn accessibility_locator_text_is_bounded_by_utf8_bytes() -> Result<(), Box<dyn Error>> {
+    let maximum_role = "r".repeat(MAX_BROWSER_ACCESSIBILITY_QUERY_ROLE_BYTES);
+    let maximum_name = "n".repeat(MAX_BROWSER_ACCESSIBILITY_QUERY_NAME_BYTES);
+    let query = WebDriverBiDiAccessibilityQuery::new(
+        Some(&maximum_role),
+        Some(&maximum_name),
+        MAX_BROWSER_ACCESSIBILITY_QUERY_NODE_COUNT,
+    )?;
+    assert_eq!(query.role(), Some(maximum_role.as_str()));
+    assert_eq!(query.name(), Some(maximum_name.as_str()));
+
+    let overlong_role = "r".repeat(MAX_BROWSER_ACCESSIBILITY_QUERY_ROLE_BYTES + 1);
+    assert_eq!(
+        WebDriverBiDiAccessibilityQuery::new(Some(&overlong_role), None, 1),
+        Err(WebDriverBiDiAccessibilityQueryError::RoleTooLong)
+    );
+
+    let overlong_name = "n".repeat(MAX_BROWSER_ACCESSIBILITY_QUERY_NAME_BYTES + 1);
+    assert_eq!(
+        WebDriverBiDiAccessibilityQuery::new(None, Some(&overlong_name), 1),
+        Err(WebDriverBiDiAccessibilityQueryError::NameTooLong)
+    );
+    Ok(())
+}
+
+#[test]
+fn accessibility_query_node_count_is_finite_and_nonzero() {
+    assert_eq!(
+        WebDriverBiDiAccessibilityQuery::new(Some("button"), None, 0),
+        Err(WebDriverBiDiAccessibilityQueryError::InvalidNodeCount)
+    );
+    assert_eq!(
+        WebDriverBiDiAccessibilityQuery::new(
+            Some("button"),
+            None,
+            MAX_BROWSER_ACCESSIBILITY_QUERY_NODE_COUNT + 1,
+        ),
+        Err(WebDriverBiDiAccessibilityQueryError::InvalidNodeCount)
+    );
+}
+
+#[test]
+fn accessibility_query_revalidates_returned_node_count() -> Result<(), Box<dyn Error>> {
+    let query = WebDriverBiDiAccessibilityQuery::new(Some("button"), None, 2)?;
+
+    assert_eq!(query.validate_result_count(0), Ok(()));
+    assert_eq!(query.validate_result_count(2), Ok(()));
+    assert_eq!(
+        query.validate_result_count(3),
+        Err(WebDriverBiDiAccessibilityQueryError::ResultNodeCountExceeded)
+    );
+    Ok(())
+}
+
+#[test]
+fn accessibility_query_error_contract_is_source_free() {
+    let errors = [
+        WebDriverBiDiAccessibilityQueryError::MissingLocatorValue,
+        WebDriverBiDiAccessibilityQueryError::EmptyRole,
+        WebDriverBiDiAccessibilityQueryError::RoleTooLong,
+        WebDriverBiDiAccessibilityQueryError::EmptyName,
+        WebDriverBiDiAccessibilityQueryError::NameTooLong,
+        WebDriverBiDiAccessibilityQueryError::InvalidNodeCount,
+        WebDriverBiDiAccessibilityQueryError::ResultNodeCountExceeded,
+    ];
+
+    for error in errors {
+        assert!(error.source().is_none());
+        assert!(!error.to_string().is_empty());
+    }
+}