interceptor-multilang 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2671416965532d4e88dd3a648598760b36d40ab31a4c800d791703c6d9f5a70c
+  data.tar.gz: 0bc8dffeb21a2d025c328279c07fa591d25ce7e21eff3bb7e51f5e25cedf3963
+SHA512:
+  metadata.gz: ecc64dc856756fed9435db3292c247475d21ee657a04c2fc9ed7ebf6c968b6b2229eb3d34372ec370c33d58ca3e4018a97c85be97f080d1226f693b65f067e2a
+  data.tar.gz: 7aedd14bd9f4b10040e452392b9a6327dd4b99a7599e1bbeb81bf454d02d528a7decfc6e9725407c758474fb18e6306c04af4bf2f50bf446d298d0e3eb305f7c

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+# 1.0.0
+
+First direct native SDK with device enumeration, input batches, HID metadata, edits, injection, cancellation and bundled documentation. No driver is installed by this package.

data/LICENSE

@@ -0,0 +1,28 @@
+MIT License
+
+Copyright (c) 2026 TitanCSA
+
+This license applies to the user-mode source code, examples, build scripts,
+documentation and precompiled user-mode recovery binaries in this repository.
+It does not apply to the prebuilt kernel
+driver, driver catalogs, or INF files under InstallerUI/Package/Payload; those files are
+covered by licenses/BINARY-LICENSE.txt. Third-party names and projects retain their own
+licenses and trademarks.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,46 @@
+# Interceptor MultiLang for Ruby
+
+Direct Fiddle bindings for Windows x64 Ruby 3.1+, with the native DLL bundled.
+No Python runtime, compiler or subprocess bridge is required.
+
+```sh
+gem install interceptor-multilang
+```
+
+The installation command is available after RubyGems publication.
+
+```ruby
+require 'interceptor_multilang'
+InterceptorMultiLang::Interceptor.open do |io|
+  p io.info
+end
+```
+
+Opening a client is lazy. For capture, separately install the combined Interceptor
+1.4.22.0 driver and run the script as administrator. No driver is installed by gem.
+Only one native SDK context may be open per process; use the block form or close
+the client in `ensure`. Receive is synchronous and releases Ruby's GVL; cancel
+can interrupt a receive from another Ruby thread.
+
+```ruby
+batch = io.receive(timeout: 1000)
+batch.each do |input|
+  input.field('y').value *= -1 if input.kind == 'mouse'
+end
+io.send(batch)
+```
+
+Always forward the complete batch or deliberately block/discard events.
+`batch[0].blocked = true` suppresses an event. A new receive invalidates older
+batches, including failed receives. Partial-send errors expose the accepted count;
+retrying `send` on the same current batch forwards only the remainder.
+
+The API includes `initialize_devices`, `info`, `devices`, `receive`, `send`,
+`discard`, `cancel`, `descriptor(token, report: true)`,
+`inject('mouse', {'x' => 200})` and `close`.
+HID fields retain collection, usage and element metadata; duplicate names are not
+collapsed. Sequence/timestamp values are exact Ruby integers. Binary data is a byte
+string; its native length must not change when editing a received field.
+
+[API and event fields](docs/API.md), examples and MIT [LICENSE](LICENSE) are bundled.
+Driver demo restrictions and licensing remain separate from this SDK.

data/docs/API.md

@@ -0,0 +1,75 @@
+# API and examples
+
+The short examples in `examples/` invert mouse Y and forward every other input unchanged. Install the matching driver and run them as administrator. `initialize()` is available for newly connected devices; check `ready` and `reboot_required` before capturing.
+
+## Shared behavior
+
+`receive` waits in milliseconds. Python/Node default `None`/`null`, Rust `None`, and .NET/Java/Go `-1` mean infinite. Zero is nonblocking. Timeout or cancellation returns an empty batch. Native C uses `UINT32_MAX` for infinite.
+
+Receive consumes input. Until the batch is sent or discarded, another receive is rejected. A batch has fixed membership and source order: edit its state or set `blocked`; do not resize/reorder it. Send infers counts and returns the number forwarded. Blocked events are excluded. On partial failure, the error includes `accepted`; retry the same batch to send only the remaining entries. There is no hidden retry loop.
+
+Native errors carry a Windows code and an English explanation. Python exposes `Error.code/accepted`, Node errors have `code/accepted`, .NET has `InterceptorException.Code/Accepted`, Java `Interceptor.Error.code/accepted`, Go `*interceptor.Error`, and Rust `interceptor::Error`. After a driver revocation, close the client before explicitly starting a new capture; an expired demo still requires Windows Restart.
+
+Managed input objects are detached snapshots. Their native commit references are checked against the client and current batch generation before use. Closing a client or attempting a new receive can invalidate the prior batch's send ticket. Ordinary state inspection remains safe; sending an old batch raises an error. Native C views are borrowed: use the lifetime rules in the header and do not access views concurrently with receive/close.
+
+## Input identity
+
+Each input has a kind (`keyboard`, `mouse`, `hid`, `xinput`, `xinputhid`, `gip`), a capture-scoped string `token`, sequence, QPC timestamp and a mutable blocked flag. Metadata is read-only. Tokens are not persistent hardware serial numbers; obtain them again for each capture. Sequence/timestamp are 64-bit: JavaScript uses BigInt; Java `long` preserves their unsigned bit pattern.
+
+`devices()` lists sources from the driver's capture, not every PnP child node. It opens capture and starts the demo allowance if not already started. `info()` is a read-only query. Its `active` field reports driver-wide capture activity, while `device_count` is the size of this client's last device enumeration (zero before enumeration). Its legacy `queued` field covers keyboard, mouse and HID queues; it is not an all-transport queue total. Use the returned batches for actual input activity.
+
+## State fields
+
+| Kind | Scalar fields |
+| --- | --- |
+| Keyboard | `scan_code`, `flags`, `information` |
+| Mouse | `x`, `y`, `flags`, `buttons`, signed `wheel`, `raw_buttons`, `information` |
+| XInput / GIP | read-only `packet`, `buttons`, `left_trigger`, `right_trigger`, `left_x`, `left_y`, `right_x`, `right_y`, `extra_buttons` |
+
+Keyboard flags preserve make/break and extended-key information. Mouse coordinates are relative unless the native absolute flag is set. Mouse `buttons` contains transition flags; gamepad `buttons` is a state bitmask. XInput and GIP use their native button positions and trigger ranges: XInput 0-255, GIP 0-1023, stick axes signed 16-bit. Do not interchange the protocols' button masks.
+
+HID/XInputHID expose dynamic `axes`, `triggers`, `hats`, `values`, `buttons`, and `binary_values`, plus the complete report. Python/Node use `input.state.axes`; .NET uses `input.State.Axes`; Java uses `input.state.axes`; Rust uses `input.state.axes`; Go uses `input.HID.Axes`. Scalar maps are `state` in Python/Node, `State` in .NET/Go, `state.scalars` in Java/Rust.
+
+HID scalar fields include raw value, minimum/maximum, physical range, normalized value and validity, usage page/usage, collection, report ID, data index and element. Repeated X usages remain distinct. Button `pressed` is mutable. Wide values retain their packed bytes in `data`. Flags: 1 normalized valid, 2 relative, 4 has null, 8 is null, 16 identified trigger, 32 read-only.
+
+Edit a scalar's **raw value or normalized value**. Absolute axis normalization is -1..1; identified analog triggers use 0..1. Relative/null/constant-range values may have no valid normalization. An unchanged null hat may be outside its declared ordinary angle range and is preserved. Contradictory edits or values outside valid ranges are rejected. Report and binary data lengths are immutable.
+
+HID state is the current report. Check `decode_complete` and `decode_error` before relying on decoded controls. Unknown bytes remain in the original report when forwarded unchanged; proprietary meaning is not guessed.
+
+## Injection and descriptors
+
+Create input for an existing captured source with `inject`. Supplying a token selects that exact source. Omitting it selects the first device of the requested kind. The normal send operation always retains the original captured source.
+
+```python
+with Interceptor() as io:
+    mouse = next(d for d in io.devices() if d.kind == "mouse")
+    io.inject("mouse", token=mouse.token, x=200, y=0)
+```
+
+Python supports named state keywords; Node accepts `{kind, token?, state, report?}`; .NET accepts `Inject(kind, stateDictionary, token?, report?)`; Java accepts `inject(kind, stateMap, token, report)`; Rust accepts kind, a slice of name/value pairs, optional token and optional report. Go uses a state map and an optional `Injection{Token: ..., Report: ...}`. Raw HID injection requires a valid report for that device. GIP synthetic input uses named standard state; captured GIP preserves its original complete report and extensions.
+
+`descriptor(token, report=false)` returns common descriptor data. `report=true` requests the **actual raw HID report descriptor**, where accessible. XUSB/GIP return not applicable. An unsupported descriptor transport returns an error; the wrapper does not substitute Windows preparsed data for a raw HID report descriptor. Formats: 0 identity, 1 HID preparsed data, 2 GIP metadata, 3 raw HID report descriptor.
+
+## Java
+
+From the extracted release folder, using JDK 22+:
+
+```powershell
+javac -cp bindings/java/Interceptor.jar -d examples/java examples/java/Remap.java
+java --enable-native-access=ALL-UNNAMED -cp "bindings/java/Interceptor.jar;examples/java" Remap
+```
+
+The native-access flag is required by the JDK's Foreign Function and Memory API. No JNI build or third-party Java dependency is needed. Keep the release's `runtimes/win-x64/` folder, or place the DLL beside the JAR.
+
+## Add to another application
+
+- Python: install the bundled Windows x64 wheel in the application's environment.
+- Node/TypeScript: `npm install ./packages/titancsa-interceptor-multilang-1.0.0.tgz`, then import `@titancsa/interceptor-multilang`.
+- .NET: use the local `TitanCSA.Interceptor` NuGet package or reference `bindings/dotnet/Interceptor.csproj`.
+- Java/Kotlin: add `bindings/java/Interceptor.jar` to the classpath.
+- Go: import the source module in `bindings/go`; distribute `InterceptorBridge.dll` beside the final EXE.
+- Rust: use a path dependency on `bindings/rust`. Its build script links the import library and copies the DLL beside the executable. `INTERCEPTOR_LIB_DIR` can select another directory containing matching DLL/LIB files.
+- C: link `InterceptorBridge.lib`, include `InterceptorBridge.h` and distribute the DLL beside the EXE.
+- C++: compile `sdk/Interceptor.cpp` once and include `sdk/Interceptor.h`; the unchanged upstream SDK remains available directly.
+
+For development/testing, `INTERCEPTOR_NATIVE_PATH` can explicitly select a matching native DLL. Node uses `INTERCEPTOR_NODE_PATH` for a matching addon. Do not select the synthetic test backend for normal capture. Paths are resolved to supplied files; installation does not add global PATH entries or a wrapper service.

data/examples/info.rb

@@ -0,0 +1,2 @@
+require 'interceptor_multilang'
+InterceptorMultiLang::Interceptor.open { |io| p io.info }

data/lib/interceptor_multilang.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+require 'fiddle'
+require 'thread'
+
+module InterceptorMultiLang
+  VERSION = '1.0.0'
+  KINDS = ['', 'keyboard', 'mouse', 'hid', 'xinput', 'xinputhid', 'gip'].freeze
+  class NativeError < StandardError
+    attr_reader :code, :accepted
+    def initialize(code, message, accepted = 0)
+      @code, @accepted = code, accepted
+      super(message)
+    end
+  end
+  Field = Struct.new(:value, :normalized, :data, :metadata, keyword_init: true)
+  Input = Struct.new(:kind, :token, :sequence, :timestamp, :fields, :metadata, :blocked, keyword_init: true) do
+    def field(name)
+      found = fields.select { |f| f.metadata[:name] == name }
+      raise ArgumentError, 'Field is absent or ambiguous; use descriptor metadata' unless found.length == 1
+      found.first
+    end
+  end
+  class Batch
+    include Enumerable
+    attr_reader :events
+    def initialize(events) = @events = events.freeze
+    def each(&block) = @events.each(&block)
+    def [](index) = @events[index]
+    def size = @events.size
+    alias length size
+  end
+
+  # All pointer/layout operations stay private; callers edit copied field values.
+  class Native
+    I = Fiddle::TYPE_INT
+    Q = Fiddle::TYPE_LONG_LONG
+    P = Fiddle::TYPE_VOIDP
+    SPECS = {
+      version: [], sizeof: [I], open: [P,P], close: [Q,P], initialize: [Q,P,P],
+      info_get: [Q,P,P], devices_get: [Q,P,P], receive: [Q,I,P,P], send: [Q,Q,P],
+      discard: [Q,Q,P], cancel: [Q,P], descriptor: [Q,P,I,P,P], inject: [Q,P,I,P]
+    }.freeze
+    @libraries = {}
+    @libraries_mutex = Mutex.new
+    def self.load(path)
+      @libraries_mutex.synchronize { @libraries[path] ||= new(path) }
+    end
+    def initialize(path)
+      @library = Fiddle.dlopen(path)
+      @functions = SPECS.to_h { |name, args| [name, Fiddle::Function.new(@library["icb_#{name}"], args, I)] }
+    end
+    def call(name, *arguments) = @functions.fetch(name).call(*arguments)
+    def self.buffer(length)
+      pointer = Fiddle::Pointer.malloc([length,1].max, Fiddle::RUBY_FREE)
+      pointer[0,[length,1].max] = "\0" * [length,1].max
+      pointer
+    end
+    def self.u32(p, off) = p[off,4].unpack1('L<')
+    def self.u64(p, off) = p[off,8].unpack1('Q<')
+    def self.i64(p, off) = p[off,8].unpack1('q<')
+    def self.pointer(p, off) = Fiddle::Pointer.new(u64(p,off))
+    def self.text(p) = p.null? ? '' : p.to_s.force_encoding(Encoding::UTF_8)
+    def self.signed64(value) = value >= (1 << 63) ? value - (1 << 64) : value
+  end
+
+  class Interceptor
+    def initialize(library_path: nil)
+      raise LoadError, 'Interceptor requires Windows x64 Ruby' unless /mswin|mingw/ =~ RUBY_PLATFORM && Fiddle::SIZEOF_VOIDP == 8
+      path = library_path || ENV['INTERCEPTOR_NATIVE_PATH'] || File.expand_path('../native/InterceptorBridge.dll', __dir__)
+      @native = Native.load(File.expand_path(path)); @mutex = Mutex.new; @session = 0; @current = nil
+      raise LoadError, 'Incompatible native ABI' unless @native.call(:version) == 1 && [120,64,24,40,776,56].each_with_index.all? { |size,index| @native.call(:sizeof,index+1) == size }
+      out = Native.buffer(8); checked(:open,out); @session = Native.u64(out,0)
+    end
+    def checked(name, *arguments)
+      error = Native.buffer(776)
+      code = @native.call(name, *arguments, error)
+      raise NativeError.new(code, error[8,768].split("\0",2).first.force_encoding('UTF-8'), Native.u32(error,4)) unless code.zero?
+      Native.u32(error,4)
+    end
+    private :checked
+    def active
+      raise IOError, 'Interceptor is closed' if @session.zero?
+      Native.signed64(@session)
+    end
+    private :active
+    def initialize_devices
+      @mutex.synchronize do
+        out = Native.buffer(24); checked(:initialize,active,out)
+        %i[ready reboot_required associated already_associated skipped].each_with_index.to_h { |name,index| [name,Native.u32(out,index*4)] }
+      end
+    end
+    def info
+      @mutex.synchronize do
+        out = Native.buffer(56); checked(:info_get,active,out)
+        result = %i[installed active trial_state input_mask controller_mask device_count queued last_reset].each_with_index.to_h { |name,index| [name,Native.u32(out,index*4)] }
+        %i[remaining_ms timestamp_frequency generation].each_with_index { |name,index| result[name] = Native.u64(out,32+index*8) }
+        result
+      end
+    end
+    def devices
+      @mutex.synchronize do
+        out = Native.buffer(8); checked(:devices_get,active,out); list = Native.pointer(out,0); items = Native.pointer(list,8)
+        Array.new(Native.u32(list,0)) do |i|
+          d = items + i*40
+          result = { kind: KINDS[Native.u32(d,0)], id: Native.u32(d,4) }
+          %i[vid pid usage_page usage].each_with_index { |name,index| result[name] = d[8+index*2,2].unpack1('S<') }
+          %i[token name hardware_id].each_with_index { |name,index| result[name] = Native.text(Native.pointer(d,16+index*8)) }
+          result
+        end
+      end
+    end
+    def receive(timeout: nil)
+      raise ArgumentError, 'Invalid timeout' unless timeout.nil? || timeout.is_a?(Integer) && timeout.between?(0,0xfffffffe)
+      @mutex.synchronize do
+        @current = nil; @header = nil
+        out = Native.buffer(8); checked(:receive,active,timeout.nil? ? -1 : (timeout >= (1 << 31) ? timeout - (1 << 32) : timeout),out)
+        @header = Native.pointer(out,0); @ticket = Native.u64(@header,0); @views = Native.pointer(@header,16)
+        events = Array.new(Native.u32(@header,8)) do |i|
+          e = @views + i*64; fs = Native.pointer(e,32)
+          fields = Array.new(Native.u32(e,40)) do |j|
+            f = fs + j*120
+            m = {name: Native.text(Native.pointer(f,0)), minimum: Native.i64(f,16), maximum: Native.i64(f,24), physical_minimum: Native.i64(f,32), physical_maximum: Native.i64(f,40)}
+            %i[group index usage_page usage collection report_id data_index element flags units units_exponent bit_size].each_with_index { |name,index| m[name] = Native.u32(f,56+index*4) }
+            bytes = Native.u32(f,112)
+            Field.new(value: Native.i64(f,8), normalized: f[48,8].unpack1('E'), data: bytes.zero? ? ''.b : Native.pointer(f,104)[0,bytes], metadata: m.freeze)
+          end.freeze
+          Input.new(kind: KINDS[Native.u32(e,0)], token: Native.text(Native.pointer(e,24)), sequence: Native.u64(e,8), timestamp: Native.u64(e,16), fields: fields,
+            metadata: %i[decode_error decode_complete parser_status device].each_with_index.to_h { |name,index| [name,Native.u32(e,44+index*4)] }.freeze, blocked: Native.u32(e,4) != 0)
+        end
+        @issued_fields = events.map(&:fields); @current = Batch.new(events)
+      end
+    end
+    def validate(batch)
+      active
+      raise ArgumentError, 'Stale or foreign batch' unless batch.equal?(@current) && @header && Native.u64(@header,0) == @ticket && batch.size == Native.u32(@header,8)
+      batch.each_with_index { |event,index| raise ArgumentError, 'Do not replace/reorder fields' unless event.fields.equal?(@issued_fields[index]) }
+    end
+    private :validate
+    def send(batch)
+      @mutex.synchronize do
+        validate(batch)
+        batch.each_with_index do |event,i|
+          fs = Native.pointer(@views+i*64,32)
+          event.fields.each_with_index do |field,j|
+            raise ArgumentError, 'Field value must fit signed 64 bits' unless field.value.is_a?(Integer) && field.value.between?(-(1<<63),(1<<63)-1)
+            raise ArgumentError, 'Normalized values must be finite' unless field.normalized.is_a?(Numeric) && field.normalized.finite?
+            raise ArgumentError, 'Do not resize binary/report data' unless field.data.is_a?(String) && field.data.bytesize == Native.u32(fs+j*120,112)
+          end
+        end
+        batch.each_with_index do |event,i|
+          e = @views+i*64; e[4,4] = [event.blocked ? 1 : 0].pack('L<'); fs = Native.pointer(e,32)
+          event.fields.each_with_index do |field,j|
+            f=fs+j*120;f[8,8]=[field.value].pack('q<');f[48,8]=[field.normalized].pack('E')
+            Native.pointer(f,104)[0,field.data.bytesize]=field.data unless field.data.empty?
+          end
+        end
+        checked(:send,active,Native.signed64(@ticket))
+      end
+    end
+    def discard(batch) = @mutex.synchronize { validate(batch); checked(:discard,active,Native.signed64(@ticket)); nil }
+    def cancel = (checked(:cancel,active); nil)
+    def descriptor(token, report: false)
+      raise ArgumentError, 'Token contains NUL' if token.include?("\0")
+      @mutex.synchronize do
+        out=Native.buffer(24);checked(:descriptor,active,token+"\0",report ? 1 : 0,out);length=Native.u32(out,8)
+        { applicable: Native.u32(out,0)!=0, format: Native.u32(out,4), data: length.zero? ? ''.b : Native.pointer(out,16)[0,length] }
+      end
+    end
+    def inject(kind, state = {}, token: nil, report: nil)
+      k=KINDS.index(kind);raise ArgumentError, 'Unknown input kind' unless k && k>0
+      @mutex.synchronize do
+        count=state.size+(report.nil? ? 0 : 1);fields=Native.buffer(count*120);strings=[]
+        state.each_with_index do |(name,value),i|
+          raise ArgumentError, 'Invalid state name or value' unless name.is_a?(String) && !name.include?("\0") && value.is_a?(Integer) && value.between?(-(1<<63),(1<<63)-1)
+          name_pointer=Fiddle::Pointer[name+"\0"];strings << name_pointer;f=fields+i*120;f[0,8]=[name_pointer.to_i].pack('Q<');f[8,8]=[value].pack('q<')
+        end
+        unless report.nil?
+          raise ArgumentError, 'Report must be a byte string' unless report.is_a?(String)
+          name=Fiddle::Pointer["report\0"];data=Fiddle::Pointer[report];strings.push(name,data);f=fields+state.size*120;f[0,8]=[name.to_i].pack('Q<');f[56,4]=[7].pack('L<');f[104,8]=[data.to_i].pack('Q<');f[112,4]=[report.bytesize].pack('L<')
+        end
+        event=Native.buffer(64);event[0,4]=[k].pack('L<');event[32,8]=[fields.to_i].pack('Q<');event[40,4]=[count].pack('L<')
+        if token
+          raise ArgumentError, 'Token contains NUL' if token.include?("\0")
+          t=Fiddle::Pointer[token+"\0"];strings << t;event[24,8]=[t.to_i].pack('Q<')
+        end
+        checked(:inject,active,event,1)
+      end
+    end
+    def close
+      return if @session.zero?
+      begin; cancel; rescue NativeError; end
+      @mutex.synchronize do
+        unless @session.zero?
+          id=@session;@session=0;@current=nil;@header=nil;checked(:close,Native.signed64(id))
+        end
+      end
+      nil
+    end
+    def self.open(**options)
+      io=new(**options)
+      return io unless block_given?
+      begin; yield io; ensure; io.close; end
+    end
+  end
+end

data/test/sdk_test.rb

@@ -0,0 +1,22 @@
+require_relative '../lib/interceptor_multilang'
+def verify(condition, message); raise message unless condition; end
+io=InterceptorMultiLang::Interceptor.new
+begin
+ if ENV['INTERCEPTOR_TEST_BACKEND']=='1'
+  verify(io.initialize_devices[:ready]==1,'initialize');devices=io.devices;verify(devices.size==6,'devices');verify(devices[0][:name].include?("\u00e9"),'UTF-8')
+  batch=io.receive(timeout:0);verify(batch.size==6,'six event kinds');verify(batch[0].sequence==0x8000000000000001,'uint64')
+  batch[0].field('scan_code').value=0x30;batch[1].field('y').value *= -1
+  axes=batch[2].fields.select{|f|f.metadata[:group]==1};verify(axes.size==2,'repeated HID fields');axes[0].value=50;axes[0].normalized=0.5
+  batch[5].blocked=true;verify(io.send(batch)==5,'send/block');verify(io.send(batch)==0,'retry');verify(io.inject('mouse',{'x'=>200})==1,'inject')
+  newer=io.receive(timeout:0);begin;io.send(batch);raise 'stale accepted';rescue ArgumentError;end;io.discard(newer)
+  api=Fiddle.dlopen(ENV.fetch('INTERCEPTOR_NATIVE_PATH'));mode=Fiddle::Function.new(api['icb_test_mode'],[Fiddle::TYPE_INT],Fiddle::TYPE_VOID)
+  mode.call(1);result=nil;t=Thread.new {result=io.receive};sleep 0.05;io.cancel;t.join(2);verify(!t.alive? && result.size==0,'cancellation');mode.call(0)
+  io.close;other=InterceptorMultiLang::Interceptor.new
+  begin;begin;other.send(newer);raise 'foreign accepted';rescue ArgumentError;end;ensure;other.close;end
+  puts 'Ruby fixture passed: six families, UTF-8, uint64, edits, HID, send/block, retry, injection, stale/foreign and threaded cancellation'
+ else
+  puts 'Ruby bundled production native DLL lazy open/close passed'
+ end
+ensure
+ io.close
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: interceptor-multilang
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- TitanCSA
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: fiddle
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: Fiddle bindings with native DLL, API docs and examples. The matching
+  input driver is installed separately.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- docs/API.md
+- examples/info.rb
+- lib/interceptor_multilang.rb
+- native/InterceptorBridge.dll
+- test/sdk_test.rb
+homepage: https://github.com/TitanCSA/Interceptor-MultiLang
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/TitanCSA/Interceptor-MultiLang
+  documentation_uri: https://github.com/TitanCSA/Interceptor-MultiLang/blob/main/docs/API.md
+  bug_tracker_uri: https://github.com/TitanCSA/Interceptor-MultiLang/issues
+  allowed_push_host: https://rubygems.org
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.20
+specification_version: 4
+summary: Direct Windows x64 Interceptor input SDK for Ruby
+test_files: []