winipc 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 628224ea1bed3bec0541f134c74f786132ffc060750d07af59e1f97f0273d484
-  data.tar.gz: af11bf3b0527555f5cc1df9542dee9b8e3c8249d52fbf3999e1b461028d052f5
+  metadata.gz: '01972cb47231455db57df188c471e00f7ace66e3721da7ba411125d17acf1760'
+  data.tar.gz: 9aa7d8e1e0153cff4167379f023cf8cedea3703228003de14b763889b99f9a61
 SHA512:
-  metadata.gz: a8c03faa73dcddedd6727f5784d311c361ebadd4c93efe16ef1519dbae81e6049bbccc5bdf580606338c55dc7d806dbe1ae026146e7a777547f100329b8da497
-  data.tar.gz: 7ec5eb17dc9d44200e40676b0425865f11a79e5e5faf11d33550e0ca8d2a1d3825bbf40773669640e838c11cda362158193b98c7ba8a684e82f7fa4296b72dea
+  metadata.gz: 9a03d3557987c8c38cabb115e711486e4787cfe339d776867f69c3d721b1c418c7d30c6c1fadab525fec493dfceed5b1ffcd4744f7705cb88608a76dd94a5663
+  data.tar.gz: 7bcd9c1c5db77486b3a9c9b031ada85f96f0998e2c5a201d7f948fd4124b45f8ba62f9af5a6742e0e87ffaa0190f8ed9efa912c7aeb6eb869761f952b6fa920d

data/README.md

@@ -1,154 +1,11 @@
-# winipc
-
-**Windows local IPC for Ruby: named pipes, shared memory, and named synchronization — safe by default, and cooperative under a fiber scheduler.**
-
-`winipc` is a native extension that exposes the three pillars of Windows
-inter-process communication through an ergonomic, hard-to-misuse Ruby API:
-
-- **Named pipes** — a duplex server and a connect-with-retry client, byte or
-  message framed. Opened for overlapped I/O, so blocking calls release the GVL
-  and (under a fiber scheduler such as [winloop](https://rubygems.org/gems/winloop))
-  run **cooperatively** instead of stalling the loop.
-- **Shared memory** — pagefile-backed named regions (`CreateFileMapping`), with
-  bounds-checked reads and writes.
-- **Named synchronization** — cross-process **Mutex**, **Event**, and
-  **Semaphore**, with auto-releasing block forms.
-
-It is **secure by default**: pipe servers reject remote clients and restrict the
-pipe to the current user (closing the documented default ACL that grants
-`Everyone` read), the first instance is created with
-`FILE_FLAG_FIRST_PIPE_INSTANCE` so a squatter can't pre-own the name, and no
-handle is inheritable.
-
-## Requirements
-
-- **Windows** with a native **MSVC (mswin)** Ruby. Not supported on MinGW/UCRT.
-- Visual Studio 2017+ / Build Tools with the **Desktop development with C++** workload.
-
-## Install
-
-```sh
-gem install winipc
-```
-
-## Named pipes
-
-```ruby
-require "winipc"
-
-# Server (one process)
-Winipc::Pipe.listen("myapp/control") do |server|
-  server.serve do |conn|             # accept + yield + close, in a loop
-    request = conn.read(4096)
-    conn.write("ack: #{request}")
-  end
-end
-
-# Client (another process)
-Winipc::Pipe.connect("myapp/control", timeout: 5) do |c|
-  c.write("hello")
-  puts c.read(4096)                  # => "ack: hello"
-end
-```
-
-`read` returns `nil` at a clean EOF (peer closed), exactly like `IO#read`; a peer
-dying mid-stream raises `Winipc::BrokenPipe`. **Message mode** preserves message
-boundaries:
-
-```ruby
-Winipc::Pipe.listen("svc", mode: :message) { |s| c = s.accept; c.read_message }
-Winipc::Pipe.connect("svc", mode: :message) { |c| c.write_message("one whole message") }
-```
-
-### Cooperative under winloop
-
-Because pipe handles are overlapped and the blocking calls release the GVL, a
-server and many clients can run as fibers on a single IOCP loop:
-
-```ruby
-require "winloop"
-Winloop.run do
-  Fiber.schedule { Winipc::Pipe.listen("svc") { |s| s.serve { |c| c.write(c.read(1024)) } } }
-  Fiber.schedule { Winipc::Pipe.connect("svc") { |c| c.write("hi"); c.read(1024) } }
-end
-```
-
-Under a scheduler, each blocking winipc call is offloaded to a worker thread and
-the calling fiber parks, so the loop keeps serving other fibers. With no
-scheduler, the same calls just block the calling thread (releasing the GVL).
-
-## Shared memory
-
-```ruby
-# Process A
-shm = Winipc::SharedMemory.create("myapp/buffer", 4096)
-shm.write(0, "shared payload")
-
-# Process B
-shm = Winipc::SharedMemory.open("myapp/buffer")
-shm.read(0, 14)                      # => "shared payload"
-```
-
-Reads and writes are bounds-checked (`Winipc::RangeError` outside the region).
-Pair shared memory with a named `Event` to hand off deterministically rather
-than polling.
-
-> **Size note:** the creator's `#size` is exactly the requested size; an
-> **opener**'s `#size` is the page-rounded mapped region (Windows rounds a
-> mapping up to the page boundary and doesn't record the logical size), so an
-> opener may read/write within the rounded region. If the exact length matters,
-> carry it out-of-band (e.g. store it in the first bytes of the region).
-
-## Named synchronization
-
-```ruby
-# Cross-process mutex
-m = Winipc::Mutex.create("myapp/lock")
-m.synchronize { critical_section }   # always released, even on exception
-
-# Event (one process waits, another signals)
-ev = Winipc::Event.create("myapp/ready", manual_reset: true)
-ev.wait(timeout: 10)                 # => true (signaled) / false (timed out)
-ev.signal
-
-# Counting semaphore
-sem = Winipc::Semaphore.create("myapp/slots", initial: 3, maximum: 3)
-sem.synchronize { use_a_slot }
-```
-
-`Mutex` is owned by the acquiring **thread**, so its waits are not offloaded to a
-worker (they release the GVL but, under a fiber scheduler, block the loop for the
-duration). Use `Event`/`Semaphore` — which any thread may wait on and signal —
-for fiber-cooperative coordination. An abandoned mutex (its holder died) is
-surfaced as `Winipc::Abandoned` / `#abandoned?` rather than silently ignored.
-
-## Errors
-
-```
-StandardError
-└─ Winipc::Error
-    ├─ Winipc::OSError          # a Windows API failed; #code is GetLastError
-    │   ├─ Winipc::TimeoutError   ├─ Winipc::BrokenPipe   ├─ Winipc::NotOwner
-    │   ├─ Winipc::NotFound       ├─ Winipc::PipeBusy     └─ Winipc::WouldExceedMax
-    │   ├─ Winipc::Exists         ├─ Winipc::Canceled
-    │   └─ Winipc::AccessDenied
-    ├─ Winipc::ModeError        # byte/message-mode misuse
-    ├─ Winipc::RangeError       # shared-memory access out of bounds
-    ├─ Winipc::Closed           # operating on a closed object
-    └─ Winipc::Abandoned        # a mutex's previous owner died holding it
-```
-
-## Notes
-
-- **Names** are bare (`"myapp/control"`); winipc maps them to `\\.\pipe\…` for
-  pipes and the `Local\` kernel namespace for shared memory / sync objects (pass
-  `scope: :global` for the `Global\` namespace, which may need privileges).
-- Every kernel handle lives in a wrapper whose finalizer closes it, so a
-  forgotten `#close` never leaks — but closing explicitly is good manners.
-- Blocking calls (`accept`, `read`, `write`, `wait`/`lock`/`acquire`) release the
-  GVL and are interruptible (`Thread#kill`, `Ctrl-C`, `Timeout`).
-- **Windows/MSVC only.** Links `kernel32` + `advapi32`, built with `cl.exe`.
-
-## License
-
-[MIT](LICENSE.txt).
+# winipc (discontinued)
+
+**winipc is no longer maintained.** This final release (0.1.1) contains no
+code: installing it compiles nothing, and `require "winipc"` raises a
+`LoadError` explaining the discontinuation.
+
+Use UNIXSocket (supported on Windows 10+), or win32-mmap / win32-event / win32-mutex instead.
+
+Earlier releases remain on RubyGems only because RubyGems does not allow
+versions older than 30 days to be yanked. They are unmaintained and not
+recommended.

data/lib/winipc.rb

@@ -1,338 +1,4 @@
-# frozen_string_literal: true
-
-require "winipc/version"
-require "winipc/winipc" # native extension: classes + errors + K_* constants
-
-# winipc — Windows local IPC for Ruby: named pipes, shared memory, and named
-# synchronization objects, with a safe-by-default API.
-#
-#   # named pipe, server side
-#   Winipc::Pipe.listen("myapp/control") do |server|
-#     conn = server.accept
-#     puts conn.read(1024)
-#     conn.write("ack")
-#     conn.close
-#   end
-#
-#   # client side (another process)
-#   Winipc::Pipe.connect("myapp/control") do |c|
-#     c.write("hello")
-#     c.read(1024)
-#   end
-module Winipc
-  # ---- Win32 flag values (verified) --------------------------------------
-  PIPE_ACCESS_INBOUND      = 0x00000001
-  PIPE_ACCESS_OUTBOUND     = 0x00000002
-  PIPE_ACCESS_DUPLEX       = 0x00000003
-  FILE_FLAG_OVERLAPPED     = 0x40000000
-  PIPE_TYPE_MESSAGE        = 0x00000004
-  PIPE_READMODE_MESSAGE    = 0x00000002
-  PIPE_WAIT                = 0x00000000
-  PIPE_REJECT_REMOTE_CLIENTS = 0x00000008
-  PIPE_UNLIMITED_INSTANCES = 255
-  GENERIC_READ             = 0x80000000
-  GENERIC_WRITE            = 0x40000000
-
-  # A Windows API failure carries the originating error code (GetLastError /
-  # the failing return), set on the exception in C.
-  class OSError
-    def code
-      @code
-    end
-  end
-
-  module_function
-
-  # Run a blocking native call cooperatively. Under a Fiber scheduler (e.g.
-  # winloop) the call is offloaded to a worker Thread so the calling fiber
-  # parks (Thread#value routes through the scheduler) and the event loop keeps
-  # serving other fibers; with no scheduler it runs inline (the C call already
-  # releases the GVL). On fiber unwind the worker is killed+joined so it can't
-  # leak or consume data destined for a later op.
-  #
-  # Caveat: if the fiber is unwound (e.g. Timeout) in the instant after the
-  # worker acquired a resource but before the value was delivered, that
-  # acquisition is lost — there is no generic way to hand it back (the same
-  # inherent limitation as a cancelled read that already pulled bytes).
-  def run_blocking
-    sched = Fiber.scheduler
-    return yield unless sched
-
-    worker = Thread.new do
-      Thread.current.report_on_exception = false
-      yield
-    end
-    begin
-      worker.value
-    ensure
-      if worker.alive?
-        worker.kill
-        worker.join
-      end
-    end
-  end
-
-  # Normalize a bare pipe name to the \\.\pipe\ namespace (pass a full
-  # \\server\pipe\name through unchanged).
-  def pipe_path(name)
-    s = name.to_s
-    s.start_with?("\\\\") ? s : "\\\\.\\pipe\\#{s}"
-  end
-
-  # Map a bare object name into the Local\ (default) or Global\ namespace.
-  def obj_path(name, scope)
-    prefix = case scope
-             when :local  then "Local\\"
-             when :global then "Global\\"
-             else raise ArgumentError, "scope must be :local or :global, got #{scope.inspect}"
-             end
-    "#{prefix}#{name}"
-  end
-
-  def server_access(direction)
-    case direction
-    when :duplex   then PIPE_ACCESS_DUPLEX
-    when :inbound  then PIPE_ACCESS_INBOUND
-    when :outbound then PIPE_ACCESS_OUTBOUND
-    else raise ArgumentError, "direction must be :duplex/:inbound/:outbound"
-    end
-  end
-  private_class_method :server_access
-
-  def client_access(direction)
-    case direction
-    when :duplex then GENERIC_READ | GENERIC_WRITE
-    when :read   then GENERIC_READ
-    when :write  then GENERIC_WRITE
-    else raise ArgumentError, "direction must be :duplex/:read/:write"
-    end
-  end
-  private_class_method :client_access
-
-  def ms_for(timeout)
-    return -1 if timeout.nil? # INFINITE (block until signaled / connected)
-
-    t = Float(timeout)
-    raise ArgumentError, "timeout must be non-negative, got #{timeout.inspect}" if t.negative?
-
-    ms = (t * 1000).round
-    # Never collapse a tiny-but-positive wait into a non-blocking poll.
-    ms.zero? && t.positive? ? 1 : ms
-  end
-
-  class Pipe
-    # Create a named-pipe server. Yields a Listener (auto-closed) if a block is
-    # given, else returns it.
-    def self.listen(name, mode: :byte, direction: :duplex, max_instances: :unlimited,
-                    in_buffer: 65_536, out_buffer: 65_536, reject_remote: true, access: :owner)
-      open_mode = Winipc.send(:server_access, direction) | FILE_FLAG_OVERLAPPED
-      pipe_mode = PIPE_WAIT
-      pipe_mode |= PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE if mode == :message
-      pipe_mode |= PIPE_REJECT_REMOTE_CLIENTS if reject_remote
-      max = max_instances == :unlimited ? PIPE_UNLIMITED_INSTANCES : Integer(max_instances)
-      raise ArgumentError, "max_instances must be 1..255" unless (1..255).cover?(max)
-
-      listener = _listen(Winipc.pipe_path(name), open_mode, pipe_mode, max,
-                         Integer(in_buffer), Integer(out_buffer), access)
-      return listener unless block_given?
-
-      begin
-        yield listener
-      ensure
-        listener.close
-      end
-    end
-
-    # Connect to a named-pipe server. Yields a Conn (auto-closed) if a block is
-    # given, else returns it.
-    # +timeout+: nil fails fast if the server isn't connectable now; a number of
-    # seconds retries (server busy or not yet up) until it elapses.
-    def self.connect(name, mode: :byte, direction: :duplex, timeout: nil)
-      access = Winipc.send(:client_access, direction)
-      ms =
-        if timeout.nil?
-          0 # fail fast if the server isn't connectable now
-        else
-          t = Float(timeout)
-          raise ArgumentError, "timeout must be non-negative, got #{timeout.inspect}" if t.negative?
-
-          msr = (t * 1000).round
-          msr.zero? && t.positive? ? 1 : msr # a tiny positive timeout still waits, not fail-fast
-        end
-      conn = Winipc.run_blocking do
-        _connect(Winipc.pipe_path(name), access, mode == :message, ms)
-      end
-      return conn unless block_given?
-
-      begin
-        yield conn
-      ensure
-        conn.close
-      end
-    end
-
-    class Listener
-      # Accept the next client. Blocks (cooperatively under a scheduler). With a
-      # timeout, returns nil if none connects in time.
-      def accept(timeout: nil)
-        Winipc.run_blocking { _accept(Winipc.ms_for(timeout)) }
-      end
-
-      # Accept clients in a loop, yielding (and closing) each connection.
-      def serve
-        loop do
-          conn = accept
-          break if conn.nil?
-
-          begin
-            yield conn
-          ensure
-            conn.close
-          end
-        end
-      end
-    end
-
-    class Conn
-      # Read up to +maxlen+ bytes (byte mode). Returns a binary String, or nil
-      # at clean EOF (peer closed).
-      def read(maxlen)
-        Winipc.run_blocking { _read(maxlen) }
-      end
-
-      # Read one whole message (message mode), reassembling across the buffer.
-      # Returns a binary String or nil at EOF.
-      def read_message(maxlen = 65_536)
-        raise ModeError, "winipc: pipe is not in message mode" unless message?
-
-        Winipc.run_blocking { _read_message(maxlen) }
-      end
-
-      # Write +bytes+; returns the number of bytes written.
-      def write(bytes)
-        Winipc.run_blocking { _write(bytes) }
-      end
-      alias write_message write # in message mode each write is one message
-
-      def <<(bytes)
-        write(bytes)
-        self
-      end
-    end
-  end
-
-  class SharedMemory
-    # Create a named, pagefile-backed shared-memory region of +size+ bytes.
-    def self.create(name, size, access: :readwrite, scope: :local, security: :owner)
-      _create(Winipc.obj_path(name, scope), Integer(size), access != :readonly, security)
-    end
-
-    # Open an existing named region.
-    def self.open(name, access: :readwrite, scope: :local)
-      _open(Winipc.obj_path(name, scope), access != :readonly)
-    end
-
-    # Flush a range (default: whole region) to backing storage.
-    def flush(offset = 0, len = nil)
-      _flush(offset, len)
-    end
-  end
-
-  class Mutex
-    def self.create(name, scope: :local, security: :owner)
-      _create(K_MUTEX, Winipc.obj_path(name, scope), nil, nil, security)
-    end
-
-    def self.open(name, scope: :local)
-      _open(K_MUTEX, Winipc.obj_path(name, scope))
-    end
-
-    # NOTE: a Windows mutex is owned by the acquiring THREAD, so Mutex waits are
-    # NOT offloaded to a worker (that would acquire on the wrong thread). They
-    # release the GVL but, under a fiber scheduler, block the loop for the wait.
-    # Use Event/Semaphore for fiber-cooperative coordination.
-    def lock(timeout: nil)
-      _wait(Winipc.ms_for(timeout)) != :timeout # :ok or :abandoned both acquire
-    end
-
-    def try_lock
-      lock(timeout: 0)
-    end
-
-    def unlock
-      _unlock
-      self
-    end
-
-    def synchronize(timeout: nil)
-      result = _wait(Winipc.ms_for(timeout))
-      raise TimeoutError, "winipc: mutex not acquired within timeout" if result == :timeout
-
-      begin
-        if result == :abandoned
-          raise Abandoned, "winipc: mutex was abandoned by a dead owner; shared state may be inconsistent"
-        end
-
-        yield
-      ensure
-        _unlock
-      end
-    end
-  end
-
-  class Event
-    def self.create(name, manual_reset: false, initial: false, scope: :local, security: :owner)
-      _create(K_EVENT, Winipc.obj_path(name, scope), manual_reset, initial, security)
-    end
-
-    def self.open(name, scope: :local)
-      _open(K_EVENT, Winipc.obj_path(name, scope))
-    end
-
-    # Wait for the event to be signaled. Returns true, or false on timeout.
-    def wait(timeout: nil)
-      Winipc.run_blocking { _wait(Winipc.ms_for(timeout)) } == :ok
-    end
-    # #signal and #reset are defined in C.
-  end
-
-  class Semaphore
-    def self.create(name, initial:, maximum:, scope: :local, security: :owner)
-      unless maximum.is_a?(Integer) && maximum > 0 && initial.is_a?(Integer) && initial >= 0 && initial <= maximum
-        raise ArgumentError, "require 0 <= initial <= maximum and maximum > 0"
-      end
-
-      _create(K_SEM, Winipc.obj_path(name, scope), initial, maximum, security)
-    end
-
-    def self.open(name, scope: :local)
-      _open(K_SEM, Winipc.obj_path(name, scope))
-    end
-
-    # Acquire one unit. Returns true, or false on timeout.
-    def acquire(timeout: nil)
-      Winipc.run_blocking { _wait(Winipc.ms_for(timeout)) } == :ok
-    end
-
-    def try_acquire
-      acquire(timeout: 0)
-    end
-
-    # Release +count+ units; returns the previous count.
-    def release(count = 1)
-      _release(count)
-    end
-
-    # Acquire one unit for the duration of the block, then release it. (Use
-    # #acquire / #release directly for multi-unit patterns.)
-    def synchronize(timeout: nil)
-      raise TimeoutError, "winipc: semaphore not acquired within timeout" unless acquire(timeout: timeout)
-
-      begin
-        yield
-      ensure
-        _release(1)
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+raise LoadError, "winipc is discontinued and this release contains no code. Use UNIXSocket (supported on Windows 10+), or win32-mmap / win32-event / win32-mutex instead." \
+  " Earlier winipc releases are unmaintained and not recommended."

metadata

@@ -1,105 +1,31 @@
 --- !ruby/object:Gem::Specification
 name: winipc
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - ned
 bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-- !ruby/object:Gem::Dependency
-  name: rake-compiler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.2'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.2'
-- !ruby/object:Gem::Dependency
-  name: minitest
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.0'
-- !ruby/object:Gem::Dependency
-  name: vcvars
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.1'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.1.1
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.1'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.1.1
-description: |
-  winipc is a native extension that exposes Windows local inter-process
-  communication through an ergonomic, safe-by-default Ruby API: duplex named
-  pipes (byte and message mode, with a server and a connect-with-retry client),
-  pagefile-backed shared memory via named file mappings, and named
-  synchronization objects (mutex, event, semaphore). Pipe handles are opened
-  for overlapped I/O so they cooperate with a fiber scheduler, and objects are
-  created with a restrictive security descriptor by default. Windows MSVC
-  (mswin) Ruby only.
+dependencies: []
+description: winipc is discontinued. This final release contains no code and exists
+  only so that installing winipc explains the discontinuation instead of building
+  an unmaintained native extension.
 executables: []
-extensions:
-- ext/winipc/extconf.rb
+extensions: []
 extra_rdoc_files: []
 files:
-- CHANGELOG.md
 - LICENSE.txt
 - README.md
-- ext/winipc/extconf.rb
-- ext/winipc/winipc.c
 - lib/winipc.rb
-- lib/winipc/version.rb
-homepage: https://github.com/main-path/winipc
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/main-path/winipc
-  changelog_uri: https://github.com/main-path/winipc/blob/main/CHANGELOG.md
-  bug_tracker_uri: https://github.com/main-path/winipc/issues
   rubygems_mfa_required: 'true'
+post_install_message: winipc is discontinued and this release contains no code. Use
+  UNIXSocket (supported on Windows 10+), or win32-mmap / win32-event / win32-mutex
+  instead.
 rdoc_options: []
 require_paths:
 - lib
@@ -107,7 +33,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.0'
+      version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -116,6 +42,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.9
 specification_version: 4
-summary: 'Windows local IPC for Ruby: named pipes, shared memory, and named synchronization
-  objects.'
+summary: Discontinued. Use UNIXSocket (supported on Windows 10+), or win32-mmap /
+  win32-event / win32-mutex instead.
 test_files: []

data/CHANGELOG.md

@@ -1,29 +0,0 @@
-# Changelog
-
-## [0.1.0] - 2026-06-01
-
-Initial release.
-
-- **Named pipes** — `Winipc::Pipe.listen` (server with `#accept`/`#serve`) and
-  `Winipc::Pipe.connect` (connect-with-retry client); a duplex `Conn` with
-  `#read`/`#write` (byte mode) and `#read_message`/`#write_message` (message
-  mode). Overlapped I/O throughout: blocking calls release the GVL and are
-  cancelable, and run cooperatively under a fiber scheduler (winloop) by
-  offloading to a worker thread. The listener always keeps a pending instance so
-  clients never see a between-accepts gap.
-- **Shared memory** — `Winipc::SharedMemory.create`/`.open` over pagefile-backed
-  named file mappings, with bounds-checked `#read`/`#write`/`#flush`.
-- **Named synchronization** — `Winipc::Mutex`, `Winipc::Event`, and
-  `Winipc::Semaphore` with `create`/`open`, GVL-releasing interruptible waits,
-  and auto-releasing `#synchronize` block forms. Abandoned mutexes are surfaced.
-- **Secure by default** — pipe servers restrict access to the current user,
-  reject remote clients, and use `FILE_FLAG_FIRST_PIPE_INSTANCE`; handles are
-  non-inheritable; objects default to the per-session `Local\` namespace. An
-  explicit SDDL string or `:everyone` is opt-in.
-- Error taxonomy under `Winipc::Error` (`OSError` with `#code`, plus
-  `TimeoutError`, `NotFound`, `Exists`, `AccessDenied`, `BrokenPipe`, `PipeBusy`,
-  `Canceled`, `NotOwner`, `WouldExceedMax`, `ModeError`, `RangeError`, `Closed`,
-  `Abandoned`).
-
-Pure C extension over kernel32 + advapi32 (`rb_raise`/longjmp-safe; every handle
-freed by a TypedData finalizer). Windows MSVC (mswin) Ruby only.