@abot-ai/runtime 1.4.0 → 1.5.0

package/dist/src/computer-access/computer/linux-input.js

@@ -0,0 +1,174 @@
+/** Mechanical action execution. Unicode mapping and all geometry are checked before any input. */
+export const LINUX_INPUT_SOURCE = String.raw `
+def incomplete_dispatch_error(dispatch):
+    status = dispatch['status']
+    if status == 'partial':
+        return {'code': 'computer_input_partial', 'message': 'Native input was only partially dispatched. Inspect the receipt and fresh observation before another action.'}
+    if status == 'unknown':
+        return {'code': 'computer_input_unknown', 'message': 'Native input dispatch is uncertain. Inspect the receipt and fresh observation before another action.'}
+    return None
+
+def action_input_count(action):
+    kind = action.get('kind')
+    if kind == 'type_text':
+        return len(action.get('text', '')) * 2
+    if kind == 'press_keys':
+        return len(action.get('keys', [])) * 2
+    if kind == 'click':
+        return 1 + action.get('count', 1) * 2
+    if kind == 'drag':
+        return 15
+    return 1
+
+def validate_action(action, state, backend):
+    kind = action.get('kind')
+    if kind not in ['click', 'move', 'drag', 'scroll', 'type_text', 'press_keys', 'focus_window']:
+        raise NativeFailure('computer_action_unsupported')
+    bounds = state['desktop']['bounds']
+    points = []
+    if kind in ['click', 'move']:
+        points = [action['point']]
+    if kind == 'drag':
+        points = [action['from'], action['to']]
+    for point in points:
+        if not point_inside(point, bounds):
+            raise NativeFailure('computer_point_outside_desktop')
+    if kind == 'click' and action.get('count') not in [1, 2]:
+        raise NativeFailure('computer_click_count_invalid')
+    if kind in ['click', 'drag'] and action.get('button') not in ['left', 'middle', 'right']:
+        raise NativeFailure('computer_button_invalid')
+    if kind == 'drag' and (not 0 <= action.get('durationMs', -1) <= 5000):
+        raise NativeFailure('computer_drag_duration_invalid')
+    if kind == 'scroll':
+        values = [action.get('deltaX'), action.get('deltaY')]
+        if not all((isinstance(value, (int, float)) and math.isfinite(value) and (abs(value) <= 12000) for value in values)):
+            raise NativeFailure('computer_scroll_limit')
+        if any((value % 120 for value in values)):
+            raise NativeFailure('linux_scroll_fraction_unsupported')
+    if kind == 'type_text':
+        if not isinstance(action.get('text'), str) or len(action['text']) > 10000:
+            raise NativeFailure('computer_text_limit')
+        return backend.text_keys(action['text'])
+    if kind == 'press_keys':
+        if not isinstance(action.get('keys'), list) or not 1 <= len(action['keys']) <= 8:
+            raise NativeFailure('computer_keys_invalid')
+        return [backend.key(key) for key in action['keys']]
+    if kind == 'focus_window':
+        if not state['desktop']['capabilities']['windows']['available']:
+            raise NativeFailure('computer_window_focus_unavailable')
+        if not any((window['binding'] == action.get('windowBinding') for window in state['windows'])):
+            raise NativeFailure('computer_window_stale')
+    return []
+
+def require_verified_text_focus(backend, action, expected_window):
+    if action['kind'] != 'type_text':
+        return
+    if expected_window is None:
+        return
+    if backend.focused_window_binding() != expected_window:
+        raise NativeFailure('computer_focus_changed')
+
+def execute_input(backend, action, keys, cancel, deadline, id, expected_binding, expected_window=None):
+    count = action_input_count(action)
+    if action['kind'] == 'type_text':
+        count = sum(4 if shift else 2 for key, shift in keys)
+    accepted = 0
+    held_keys = []
+    held_buttons = []
+
+    def check():
+        if cancel.is_set():
+            raise NativeFailure('computer_action_cancelled')
+        if time.time() * 1000 > deadline:
+            raise NativeFailure('computer_action_deadline')
+        require_verified_text_focus(backend, action, expected_window)
+
+    def event(function, *args):
+        nonlocal accepted
+        check()
+        function(*args)
+        accepted += 1
+
+    def down_key(key):
+        event(backend.key_event, key, True)
+        held_keys.append(key)
+
+    def up_key(key):
+        nonlocal accepted
+        backend.key_event(key, False)
+        held_keys.remove(key)
+        accepted += 1
+
+    def down_button(button):
+        event(backend.button, button, True)
+        held_buttons.append(button)
+
+    def up_button(button):
+        nonlocal accepted
+        backend.button(button, False)
+        held_buttons.remove(button)
+        accepted += 1
+    check()
+    if backend.source_binding() != expected_binding:
+        raise NativeFailure('computer_desktop_stale')
+    emit({'type': 'dispatch', 'id': id, 'dispatch': {'status': 'unknown', 'requestedInputCount': count, 'reason': 'native_dispatch_started'}})
+    failure = None
+    try:
+        kind = action['kind']
+        if kind == 'move':
+            event(backend.pointer, action['point'])
+        if kind == 'click':
+            event(backend.pointer, action['point'])
+            button = {'left': 1, 'middle': 2, 'right': 3}[action['button']]
+            for index in range(action['count']):
+                check()
+                down_button(button)
+                up_button(button)
+                if index + 1 < action['count']:
+                    cancel.wait(0.05)
+        if kind == 'drag':
+            event(backend.pointer, action['from'])
+            button = {'left': 1, 'middle': 2, 'right': 3}[action['button']]
+            down_button(button)
+            for step in range(1, 13):
+                point = {axis: action['from'][axis] + (action['to'][axis] - action['from'][axis]) * step / 12 for axis in ['x', 'y']}
+                event(backend.pointer, point)
+                cancel.wait(action['durationMs'] / 12000)
+            check()
+            up_button(button)
+        if kind == 'scroll':
+            event(backend.scroll, action['deltaX'], action['deltaY'])
+        if kind == 'focus_window':
+            event(backend.focus, action['windowBinding'])
+        if kind == 'press_keys':
+            for key, shift in keys:
+                down_key(key)
+            for key, shift in reversed(keys):
+                up_key(key)
+        if kind == 'type_text':
+            for key, shift in keys:
+                check()
+                if shift:
+                    down_key(backend.key('Shift')[0])
+                down_key(key)
+                up_key(key)
+                if shift:
+                    up_key(backend.key('Shift')[0])
+    except Exception as error:
+        failure = error
+    finally:
+        for key in reversed(held_keys):
+            try:
+                backend.key_event(key, False)
+            except Exception:
+                failure = NativeFailure('computer_key_release_uncertain')
+        for button in reversed(held_buttons):
+            try:
+                backend.button(button, False)
+            except Exception:
+                failure = NativeFailure('computer_button_release_uncertain')
+    dispatch = {'status': 'accepted' if failure is None else 'partial' if accepted else 'unknown', 'requestedInputCount': count, 'acceptedInputCount': accepted}
+    if failure is not None:
+        dispatch['reason'] = failure.code if isinstance(failure, NativeFailure) else 'computer_native_action_failed'
+    return dispatch
+`;

package/dist/src/computer-access/computer/linux-portal-source.d.ts

@@ -0,0 +1,2 @@
+/** One selected portal stream has its own coordinate space and immutable source identity. */
+export declare const LINUX_PORTAL_SOURCE_IDENTITY: string;

package/dist/src/computer-access/computer/linux-portal-source.js

@@ -0,0 +1,62 @@
+/** One selected portal stream has its own coordinate space and immutable source identity. */
+export const LINUX_PORTAL_SOURCE_IDENTITY = String.raw `
+def bind_portal_capture_source(backend, source, properties):
+    serial = properties.get('pipewire-serial')
+    if serial is not None:
+        if not source.find_property('target-object'):
+            raise NativeFailure('linux_pipewire_stable_target_unavailable')
+        source.set_property('target-object', str(serial))
+    else:
+        source.set_property('path', str(backend.stream))
+    # Legacy pipewiresrc connects with DONT_RECONNECT; never rebuild this pipeline after loss.
+    if source.find_property('on-disconnect'):
+        backend.Gst.util_set_object_arg(source, 'on-disconnect', 'error')
+    selected = {key: properties[key] for key in ['id', 'mapping_id', 'pipewire-serial', 'position', 'size', 'source_type'] if key in properties}
+    return 'wayland:' + source_fingerprint([{'session': backend.session, 'node': backend.stream, 'source': selected, 'geometry': backend.geometry}])
+
+def require_portal_stream_alive(backend):
+    pipeline = getattr(backend, 'pipeline', None)
+    if pipeline is None:
+        return
+    kinds = backend.Gst.MessageType
+    for _ in range(64):
+        message = pipeline.get_bus().pop_filtered(kinds.ERROR | kinds.EOS | kinds.TAG)
+        if message is None:
+            return
+        if message.type == kinds.TAG:
+            present, orientation = message.parse_tag().get_string('image-orientation')
+            if present:
+                require_portal_orientation(backend, orientation)
+            continue
+        backend.closed = True
+        backend.invalidated_reason = 'linux_portal_source_changed'
+        return
+    backend.closed = True
+    backend.invalidated_reason = 'linux_portal_source_status_unavailable'
+
+def require_portal_orientation(backend, orientation):
+    previous = getattr(backend, 'source_orientation', None)
+    backend.source_orientation = orientation
+    if previous is None:
+        return
+    if getattr(backend, 'capture_layout', None) is None:
+        return
+    if previous == orientation:
+        return
+    backend.closed = True
+    backend.invalidated_reason = 'linux_portal_geometry_changed'
+
+def portal_frame_layout(caps):
+    structure = caps.get_structure(0)
+    return tuple(str(structure.get_value(key)) if structure.has_field(key) else '' for key in ['width', 'height', 'format', 'pixel-aspect-ratio', 'interlace-mode'])
+
+def require_portal_frame_layout(backend, caps):
+    expected = getattr(backend, 'capture_layout', None)
+    if expected is None:
+        return
+    current = portal_frame_layout(caps)
+    if current == expected:
+        return
+    backend.closed = True
+    backend.invalidated_reason = 'linux_portal_geometry_changed'
+`;

package/dist/src/computer-access/computer/linux-portal.d.ts

@@ -0,0 +1,2 @@
+/** Persistent Wayland remote-desktop portal session. No compositor-specific input shortcuts. */
+export declare const LINUX_PORTAL_SOURCE: string;

package/dist/src/computer-access/computer/linux-portal.js

@@ -0,0 +1,268 @@
+/** Persistent Wayland remote-desktop portal session. No compositor-specific input shortcuts. */
+export const LINUX_PORTAL_SOURCE = String.raw `
+class PortalDesktop:
+    BUS = 'org.freedesktop.portal.Desktop'
+    PATH = '/org/freedesktop/portal/desktop'
+    REMOTE = 'org.freedesktop.portal.RemoteDesktop'
+    SCREEN = 'org.freedesktop.portal.ScreenCast'
+
+    def __init__(self):
+        import gi
+        from gi.repository import Gio, GLib
+        self.Gio, self.GLib = (Gio, GLib)
+        self.bus = Gio.bus_get_sync(Gio.BusType.SESSION, None)
+        self.session = None
+        self.fd = None
+        self.pipeline = None
+        self.sink = None
+        self.stream = None
+        self.geometry = {'x': 0, 'y': 0, 'width': 1, 'height': 1}
+        self.binding = 'wayland:' + str(uuid.uuid4())
+        self.devices = 0
+        self.closed = False
+        self.Gst = None
+        self.remote_available = False
+        self.capture_available = False
+        self.capture_dimensions = None
+        self.capture_layout = None
+        self.invalidated_reason = None
+        self.subscriptions = []
+        try:
+            devices = self.call('org.freedesktop.DBus.Properties', 'Get', GLib.Variant('(ss)', (self.REMOTE, 'AvailableDeviceTypes'))).unpack()[0]
+            self.remote_available = bool(devices & 3)
+        except Exception:
+            pass
+        try:
+            gi.require_version('Gst', '1.0')
+            gi.require_version('GstVideo', '1.0')
+            from gi.repository import Gst, GstVideo
+            self.GstVideo = GstVideo
+            Gst.init(None)
+            if all((Gst.ElementFactory.find(name) for name in ['pipewiresrc', 'videoconvert', 'appsink'])):
+                self.Gst = Gst
+            sources = self.call('org.freedesktop.DBus.Properties', 'Get', GLib.Variant('(ss)', (self.SCREEN, 'AvailableSourceTypes'))).unpack()[0]
+            self.capture_available = bool(self.Gst and sources & 1)
+        except Exception:
+            pass
+
+    def call(self, interface, method, parameters, path=None):
+        return self.bus.call_sync(self.BUS, path or self.PATH, interface, method, parameters, None, self.Gio.DBusCallFlags.NONE, 5000, None)
+
+    def request(self, interface, method, signature, args, options, cancel):
+        token = 'abot_' + uuid.uuid4().hex
+        options = dict(options)
+        options['handle_token'] = self.GLib.Variant('s', token)
+        sender = self.bus.get_unique_name().lstrip(':').replace('.', '_')
+        path = '/org/freedesktop/portal/desktop/request/' + sender + '/' + token
+        ready = threading.Event()
+        result = {}
+
+        def received(connection, sender, path, interface, signal, parameters, data):
+            response, values = parameters.unpack()
+            result.update({'response': response, 'values': values})
+            ready.set()
+        subscription = self.bus.signal_subscribe(self.BUS, 'org.freedesktop.portal.Request', 'Response', path, None, self.Gio.DBusSignalFlags.NONE, received, None)
+        try:
+            self.call(interface, method, self.GLib.Variant(signature, tuple(args) + (options,)))
+            deadline = time.monotonic() + 30
+            while not ready.wait(0.05):
+                if cancel.is_set() or time.monotonic() > deadline:
+                    try:
+                        self.call('org.freedesktop.portal.Request', 'Close', None, path)
+                    except Exception:
+                        pass
+                    raise NativeFailure('linux_portal_request_cancelled')
+            if result['response'] != 0:
+                raise NativeFailure('linux_portal_permission_denied')
+            return result['values']
+        finally:
+            self.bus.signal_unsubscribe(subscription)
+
+    def ensure_session(self, cancel):
+        if self.closed:
+            raise NativeFailure('linux_portal_session_closed')
+        if self.session:
+            return
+        if not self.capture_available:
+            raise NativeFailure('linux_pipewire_capture_dependencies_unavailable')
+        session_interface = self.REMOTE if self.remote_available else self.SCREEN
+        session_token = 'abot_' + uuid.uuid4().hex
+        created = self.request(session_interface, 'CreateSession', '(a{sv})', [], {'session_handle_token': self.GLib.Variant('s', session_token)}, cancel)
+        self.session = created['session_handle']
+
+        def session_closed(*args):
+            self.closed = True
+        self.subscriptions.append(self.bus.signal_subscribe(self.BUS, 'org.freedesktop.portal.Session', 'Closed', self.session, None, self.Gio.DBusSignalFlags.NONE, session_closed, None))
+        try:
+            if self.remote_available:
+                self.request(self.REMOTE, 'SelectDevices', '(oa{sv})', [self.session], {'types': self.GLib.Variant('u', 3)}, cancel)
+            self.request(self.SCREEN, 'SelectSources', '(oa{sv})', [self.session], {'types': self.GLib.Variant('u', 1), 'multiple': self.GLib.Variant('b', False)}, cancel)
+            started = self.request(session_interface, 'Start', '(osa{sv})', [self.session, ''], {}, cancel)
+            self.devices = started.get('devices', 0)
+            streams = started.get('streams', [])
+            if len(streams) != 1:
+                raise NativeFailure('linux_portal_single_monitor_required')
+            self.stream, properties = streams[0]
+            size = properties.get('size')
+            if not size or size[0] <= 0 or size[1] <= 0:
+                raise NativeFailure('linux_portal_geometry_unavailable')
+            self.geometry = {'x': 0, 'y': 0, 'width': size[0], 'height': size[1]}
+            returned, fds = self.bus.call_with_unix_fd_list_sync(self.BUS, self.PATH, self.SCREEN, 'OpenPipeWireRemote', self.GLib.Variant('(oa{sv})', (self.session, {})), None, self.Gio.DBusCallFlags.NONE, 5000, None, None)
+            self.fd = fds.get(returned.unpack()[0])
+            self.pipeline = self.Gst.Pipeline.new('abot-capture')
+            source = self.Gst.ElementFactory.make('pipewiresrc', 'source')
+            source.set_property('fd', self.fd)
+            self.binding = bind_portal_capture_source(self, source, properties)
+            convert = self.Gst.ElementFactory.make('videoconvert', 'convert')
+            self.sink = self.Gst.ElementFactory.make('appsink', 'sink')
+            self.sink.set_property('caps', self.Gst.Caps.from_string('video/x-raw,format=RGB'))
+            self.sink.set_property('max-buffers', 1)
+            self.sink.set_property('drop', True)
+            self.sink.set_property('sync', False)
+            for element in [source, convert, self.sink]:
+                self.pipeline.add(element)
+            if not source.link(convert) or not convert.link(self.sink):
+                raise NativeFailure('linux_pipewire_pipeline_failed')
+            self.pipeline.set_state(self.Gst.State.PLAYING)
+        except Exception:
+            self.close()
+            raise
+
+    def inspect(self):
+        self.validate_stream_dimensions()
+        active = not self.closed and (self.remote_available or self.capture_available)
+        capture_reason = 'linux_portal_permission_required' if self.capture_available else 'linux_pipewire_capture_dependencies_unavailable'
+        input_reason = 'linux_portal_permission_required' if self.remote_available else 'linux_remote_desktop_portal_unavailable'
+        has_granted_session = bool(self.session and not self.closed)
+        result = desktop_result('linux', self.binding, self.geometry, active, cap(self.capture_available and has_granted_session, capture_reason), cap(self.remote_available and has_granted_session, input_reason), cap(False, 'wayland_window_inventory_unavailable', False), 'observed_surface')
+        result['desktop']['coordinateSpace'] = 'logical_points'
+        if self.closed:
+            result['desktop']['reason'] = self.invalidated_reason or 'linux_portal_session_closed'
+        if self.session:
+            denied_input = 'linux_portal_input_permission_partial' if self.remote_available else 'linux_remote_desktop_portal_unavailable'
+            result['desktop']['capabilities']['input'] = cap(has_granted_session and self.devices & 3 == 3, self.invalidated_reason or denied_input)
+        return result
+
+    def source_binding(self):
+        self.validate_stream_dimensions()
+        if self.closed:
+            raise NativeFailure(self.invalidated_reason or 'linux_portal_session_closed')
+        return self.binding
+
+    def validate_stream_dimensions(self):
+        require_portal_stream_alive(self)
+        if not getattr(self, 'sink', None):
+            return
+        pad = self.sink.get_static_pad('sink')
+        caps = pad.get_current_caps() if pad else None
+        if not caps:
+            return
+        require_portal_frame_layout(self, caps)
+        structure = caps.get_structure(0)
+        dimensions = (structure.get_value('width'), structure.get_value('height'))
+        if self.capture_dimensions is not None and self.capture_dimensions != dimensions:
+            self.closed = True
+            self.invalidated_reason = 'linux_portal_geometry_changed'
+
+    def capture(self, region):
+        self.validate_stream_dimensions()
+        if self.closed or not self.sink:
+            raise NativeFailure('linux_portal_session_unavailable')
+        sample = fresh_portal_sample(self)
+        require_portal_stream_alive(self)
+        require_portal_frame_layout(self, sample.get_caps())
+        if self.closed:
+            raise NativeFailure(self.invalidated_reason or 'linux_portal_session_closed')
+        structure = sample.get_caps().get_structure(0)
+        width, height = (structure.get_value('width'), structure.get_value('height'))
+        dimensions = (width, height)
+        if self.capture_dimensions is not None and dimensions != self.capture_dimensions:
+            self.closed = True
+            self.invalidated_reason = 'linux_portal_geometry_changed'
+            raise NativeFailure(self.invalidated_reason)
+        self.capture_dimensions = dimensions
+        self.capture_layout = portal_frame_layout(sample.get_caps())
+        buffer = sample.get_buffer()
+        success, mapped = buffer.map(self.Gst.MapFlags.READ)
+        if not success:
+            raise NativeFailure('linux_pipewire_frame_unavailable')
+        try:
+            info = self.GstVideo.VideoInfo.new_from_caps(sample.get_caps())
+            if info is None:
+                raise NativeFailure('linux_pipewire_pixel_format_unsupported')
+            sx = width / self.geometry['width']
+            sy = height / self.geometry['height']
+            x, y = (round(region['x'] * sx), round(region['y'] * sy))
+            w, h = (round(region['width'] * sx), round(region['height'] * sy))
+            scale = min(1.0, 2048 / max(w, h))
+            output_width, output_height = max(1, round(w * scale)), max(1, round(h * scale))
+            rows = []
+            for output_row in range(output_height):
+                row = y + min(h - 1, int(output_row / scale))
+                offset = info.offset[0] + row * info.stride[0] + x * 3
+                line = bytearray([0])
+                for output_column in range(output_width):
+                    column = min(w - 1, int(output_column / scale))
+                    line.extend(mapped.data[offset + column * 3:offset + column * 3 + 3])
+                rows.append(bytes(line))
+            return (encode_png(output_width, output_height, b''.join(rows)), output_width, output_height)
+        finally:
+            buffer.unmap(mapped)
+
+    def notify(self, method, signature, values):
+        self.validate_stream_dimensions()
+        if self.closed or not self.session:
+            raise NativeFailure('linux_portal_session_closed')
+        self.call(self.REMOTE, method, self.GLib.Variant(signature, (self.session, {}) + tuple(values)))
+
+    def pointer(self, point):
+        self.notify('NotifyPointerMotionAbsolute', '(oa{sv}udd)', [self.stream, float(point['x']), float(point['y'])])
+
+    def button(self, button, down):
+        self.notify('NotifyPointerButton', '(oa{sv}iu)', [{1: 272, 2: 274, 3: 273}[button], int(down)])
+
+    def scroll(self, x, y):
+        if x % 120 or y % 120:
+            raise NativeFailure('linux_wayland_scroll_fraction_unsupported')
+        if x:
+            self.notify('NotifyPointerAxisDiscrete', '(oa{sv}ui)', [1, int(x / 120)])
+        if y:
+            self.notify('NotifyPointerAxisDiscrete', '(oa{sv}ui)', [0, int(y / 120)])
+
+    def key_event(self, key, down):
+        self.notify('NotifyKeyboardKeysym', '(oa{sv}iu)', [key, int(down)])
+
+    def key(self, name):
+        aliases = {'Ctrl': 65507, 'Control': 65507, 'Alt': 65513, 'Shift': 65505, 'Meta': 65515, 'Super': 65515, 'Command': 65515, 'Enter': 65293, 'Escape': 65307, 'Esc': 65307, 'Tab': 65289, 'Backspace': 65288, 'Delete': 65535, 'Space': 32, 'ArrowLeft': 65361, 'ArrowUp': 65362, 'ArrowRight': 65363, 'ArrowDown': 65364, 'Home': 65360, 'End': 65367, 'PageUp': 65365, 'PageDown': 65366}
+        if name in aliases:
+            return (aliases[name], False)
+        if len(name) == 1:
+            return (ord(name) if ord(name) <= 255 else 16777216 | ord(name), False)
+        if name.startswith('F') and name[1:].isdigit() and (1 <= int(name[1:]) <= 24):
+            return (65469 + int(name[1:]), False)
+        raise NativeFailure('linux_key_unmapped')
+
+    def text_keys(self, text):
+        return [self.key({'\n': 'Enter', '\t': 'Tab'}.get(char, char)) for char in text]
+
+    def focus(self, binding):
+        raise NativeFailure('wayland_window_focus_unavailable')
+
+    def close(self):
+        self.closed = True
+        if self.pipeline:
+            self.pipeline.set_state(self.Gst.State.NULL)
+            self.pipeline = None
+        if self.fd is not None:
+            os.close(self.fd)
+            self.fd = None
+        if self.session:
+            try:
+                self.call('org.freedesktop.portal.Session', 'Close', None, self.session)
+            except Exception:
+                pass
+        for subscription in self.subscriptions:
+            self.bus.signal_unsubscribe(subscription)
+        self.subscriptions = []
+        self.session = None
+`;

package/dist/src/computer-access/computer/linux-topology.d.ts

@@ -0,0 +1,2 @@
+/** Native capture-source identity; display union bounds alone cannot identify a layout. */
+export declare const LINUX_TOPOLOGY_SOURCE: string;

package/dist/src/computer-access/computer/linux-topology.js

@@ -0,0 +1,92 @@
+/** Native capture-source identity; display union bounds alone cannot identify a layout. */
+export const LINUX_TOPOLOGY_SOURCE = String.raw `
+import hashlib
+
+def source_fingerprint(records):
+    canonical = sorted(json.dumps(record, sort_keys=True, separators=(',', ':')) for record in records)
+    return hashlib.sha256(json.dumps(canonical, separators=(',', ':')).encode()).hexdigest()
+
+class RandrResources(ctypes.Structure):
+    _fields_ = [('timestamp', ctypes.c_ulong), ('configTimestamp', ctypes.c_ulong), ('ncrtc', ctypes.c_int), ('crtcs', ctypes.POINTER(ctypes.c_ulong)), ('noutput', ctypes.c_int), ('outputs', ctypes.POINTER(ctypes.c_ulong)), ('nmode', ctypes.c_int), ('modes', ctypes.c_void_p)]
+
+class RandrCrtc(ctypes.Structure):
+    _fields_ = [('timestamp', ctypes.c_ulong), ('x', ctypes.c_int), ('y', ctypes.c_int), ('width', ctypes.c_uint), ('height', ctypes.c_uint), ('mode', ctypes.c_ulong), ('rotation', ctypes.c_ushort), ('noutput', ctypes.c_int), ('outputs', ctypes.POINTER(ctypes.c_ulong)), ('rotations', ctypes.c_ushort), ('npossible', ctypes.c_int), ('possible', ctypes.POINTER(ctypes.c_ulong))]
+
+class RandrTransform(ctypes.Structure):
+    _fields_ = [('pending', ctypes.c_int32 * 9), ('pendingFilter', ctypes.c_void_p), ('pendingCount', ctypes.c_int), ('pendingParams', ctypes.c_void_p), ('current', ctypes.c_int32 * 9), ('currentFilter', ctypes.c_void_p), ('currentCount', ctypes.c_int), ('currentParams', ctypes.c_void_p)]
+
+class X11Topology:
+    def __init__(self, desktop):
+        self.desktop = desktop
+        try:
+            self.r = ctypes.CDLL('libXrandr.so.2')
+            signatures = {
+                'XRRQueryVersion': ([ctypes.c_void_p, ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_int)], ctypes.c_int),
+                'XRRGetScreenResourcesCurrent': ([ctypes.c_void_p, ctypes.c_ulong], ctypes.POINTER(RandrResources)),
+                'XRRFreeScreenResources': ([ctypes.POINTER(RandrResources)], None),
+                'XRRGetCrtcInfo': ([ctypes.c_void_p, ctypes.POINTER(RandrResources), ctypes.c_ulong], ctypes.POINTER(RandrCrtc)),
+                'XRRFreeCrtcInfo': ([ctypes.POINTER(RandrCrtc)], None),
+                'XRRGetCrtcTransform': ([ctypes.c_void_p, ctypes.c_ulong, ctypes.POINTER(ctypes.POINTER(RandrTransform))], ctypes.c_int),
+            }
+            for name, (args, result) in signatures.items():
+                function = getattr(self.r, name)
+                function.argtypes, function.restype = args, result
+            major, minor = ctypes.c_int(), ctypes.c_int()
+            if not self.r.XRRQueryVersion(desktop.display, ctypes.byref(major), ctypes.byref(minor)):
+                raise NativeFailure('linux_randr_topology_unavailable')
+            if (major.value, minor.value) < (1, 3):
+                raise NativeFailure('linux_randr13_required')
+        except (OSError, AttributeError):
+            raise NativeFailure('linux_randr_topology_unavailable')
+
+    def resources(self):
+        resources = self.r.XRRGetScreenResourcesCurrent(self.desktop.display, self.desktop.root)
+        if not resources:
+            raise NativeFailure('linux_randr_topology_unavailable')
+        return resources
+
+    def crtc_record(self, resources, identifier):
+        pointer = self.r.XRRGetCrtcInfo(self.desktop.display, resources, identifier)
+        if not pointer:
+            raise NativeFailure('linux_randr_topology_unavailable')
+        try:
+            info = pointer.contents
+            if info.mode == 0:
+                return None
+            if not 1 <= info.noutput <= 256:
+                raise NativeFailure('linux_randr_topology_unavailable')
+            transform = ctypes.POINTER(RandrTransform)()
+            if not self.r.XRRGetCrtcTransform(self.desktop.display, identifier, ctypes.byref(transform)) or not transform:
+                raise NativeFailure('linux_randr_transform_unavailable')
+            try:
+                matrix = list(transform.contents.current)
+            finally:
+                self.desktop.x.XFree(transform)
+            return {'crtc': identifier, 'outputs': sorted(info.outputs[:info.noutput]), 'rect': [info.x, info.y, info.width, info.height], 'mode': info.mode, 'rotation': info.rotation, 'transform': matrix}
+        finally:
+            self.r.XRRFreeCrtcInfo(pointer)
+
+    def fingerprint(self):
+        resources = self.resources()
+        try:
+            info = resources.contents
+            epoch = (info.timestamp, info.configTimestamp)
+            if not 1 <= info.ncrtc <= 256:
+                raise NativeFailure('linux_randr_topology_unavailable')
+            records = []
+            for identifier in info.crtcs[:info.ncrtc]:
+                record = self.crtc_record(resources, identifier)
+                if record is not None:
+                    records.append(record)
+            if not records:
+                raise NativeFailure('linux_randr_topology_unavailable')
+            current = self.resources()
+            try:
+                if epoch != (current.contents.timestamp, current.contents.configTimestamp):
+                    raise NativeFailure('computer_topology_changed')
+            finally:
+                self.r.XRRFreeScreenResources(current)
+            return source_fingerprint([{'epoch': epoch}] + records)
+        finally:
+            self.r.XRRFreeScreenResources(resources)
+`;

package/dist/src/computer-access/computer/linux-x11.d.ts

@@ -0,0 +1,2 @@
+/** X11 server APIs; screenshots never leave memory. All input is XTEST, never a shell command. */
+export declare const LINUX_X11_SOURCE: string;