@nimbus-sh/core 0.1.0

package/dist/runtime/ruby-socket-shim.d.ts

@@ -0,0 +1,2 @@
+export declare const RUBY_SOCKET_SHIM: string;
+//# sourceMappingURL=ruby-socket-shim.d.ts.map

package/dist/runtime/ruby-socket-shim.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ruby-socket-shim.d.ts","sourceRoot":"","sources":["../../src/runtime/ruby-socket-shim.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,QAmiB5B,CAAC"}

package/dist/runtime/ruby-socket-shim.js

@@ -0,0 +1,548 @@
+export const RUBY_SOCKET_SHIM = String.raw `
+begin
+  require 'js'
+  require 'json'
+rescue LoadError => e
+  raise LoadError, "Nimbus Ruby virtual sockets require the ruby.wasm JS bridge: #{e.message}"
+end
+
+module Nimbus
+  module VirtualSocket
+    class << self
+      # The listener bridge belongs to a process that outlives the command
+      # which started it. A one-liner is answered from the pooled VM and has no
+      # such process, so nothing could hold a port open once it returns. Saying
+      # that is far more use than whatever the JS bridge throws on a handle
+      # that is not there.
+      # JS::Object descends from BasicObject, so typeof is the only question it
+      # can be asked; a global that was never set answers 'undefined'.
+      def bridge
+        handle = JS.global[:__nimbusRubySockets]
+        if handle.typeof == 'undefined'
+          raise ::SocketError,
+                'listening sockets need a Nimbus process that outlives the command, ' +
+                'and a one-liner has none: put this in a script file and run it ' +
+                'as ruby <file>.rb'
+        end
+        handle
+      end
+
+      def listen(port)
+        bridge.call(:listen, port.to_i).to_i
+      end
+
+      def close_listener(port)
+        bridge.call(:closeListener, port.to_i)
+        nil
+      end
+
+      def pending(port)
+        bridge.call(:pending, port.to_i).to_i
+      end
+
+      # Why the last socket call failed. A WASI errno cannot distinguish
+      # "nothing is listening" from "this process cannot route loopback at
+      # all", and the difference is the whole diagnosis.
+      def last_socket_error
+        JS.global[:__nimbusWasiLastSocketError].to_s
+      rescue StandardError
+        ''
+      end
+
+      # Park the process until the next inbound request resumes it, or until a
+      # deadline passes. This is what "blocking" means here: a wasm-stack
+      # suspension cannot outlive the request context that created it, so
+      # waiting has to happen in a fiber, whose state is Ruby's own memory.
+      def park(condition = nil, deadline = nil)
+        Nimbus::Threading.park(condition, deadline)
+      rescue FiberError
+        raise IOError, 'Nimbus sockets can only block inside a Nimbus process'
+      end
+
+    end
+  end
+end
+
+# ── In-memory pipe ─────────────────────────────────────────────────────────
+#
+# Real threads live in ruby-green-threads.rb, which this file relies on for
+# parking. What is left here is the other thing WASI preview1 simply does not
+# have: pipe(2). Both ends share a byte buffer, and a read with nothing in it
+# parks the caller the same way every other wait here does.
+class NimbusPipe
+  def initialize(shared)
+    @shared = shared
+    @closed = false
+  end
+
+  def write(data)
+    bytes = data.to_s.b
+    @shared << bytes
+    bytes.bytesize
+  end
+  alias syswrite write
+  alias write_nonblock write
+  alias print write
+
+  def read_nonblock(maxlen = 4096, outbuf = nil, exception: true)
+    if @shared.empty?
+      return nil unless exception
+      raise IO::EAGAINWaitReadable
+    end
+    take = @shared.byteslice(0, maxlen)
+    @shared.replace(@shared.byteslice(take.bytesize, @shared.bytesize - take.bytesize) || ''.b)
+    outbuf ? outbuf.replace(take) : take
+  end
+
+  # Blocking read: an empty pipe means "not yet", so park until a writer
+  # arrives rather than reporting a false EOF or spinning.
+  def read(maxlen = nil, outbuf = nil)
+    loop do
+      chunk = read_nonblock(maxlen || @shared.bytesize, outbuf, exception: false)
+      return chunk if chunk
+      return ''.b if @closed
+      Nimbus::Threading.park(-> { !@shared.empty? || @closed })
+    end
+  end
+  alias sysread read
+  alias readpartial read
+
+  def gets(_sep = $/, _limit = nil)
+    read(@shared.bytesize)
+  end
+
+  def __nimbus_socket_ready?
+    !@shared.empty?
+  end
+
+  def to_io
+    self
+  end
+
+  def fileno
+    -1
+  end
+
+  def flush
+    self
+  end
+
+  def sync
+    true
+  end
+
+  def sync=(value)
+    value
+  end
+
+  def close
+    @closed = true
+    nil
+  end
+
+  def closed?
+    @closed
+  end
+end
+
+class << IO
+  unless method_defined?(:__nimbus_original_pipe)
+    alias_method :__nimbus_original_pipe, :pipe
+    def pipe(*)
+      shared = ''.b
+      ends = [NimbusPipe.new(shared), NimbusPipe.new(shared)]
+      return ends unless block_given?
+      begin
+        yield(*ends)
+      ensure
+        ends.each(&:close)
+      end
+    end
+  end
+end
+
+# Normally defined by the socket extension, which ruby.wasm does not ship, so
+# raising it from this shim would fail with "uninitialized constant" instead.
+class SocketError < StandardError; end unless defined?(::SocketError)
+
+class BasicSocket
+  attr_accessor :do_not_reverse_lookup, :sync, :autoclose
+
+  def nonblock=(value)
+    @__nimbus_nonblock = !!value
+  end
+
+  def nonblock?
+    !!@__nimbus_nonblock
+  end
+
+  def nonblock
+    previous = nonblock?
+    self.nonblock = true
+    return self unless block_given?
+    begin
+      yield self
+    ensure
+      self.nonblock = previous
+    end
+  end
+
+  def setsockopt(*)
+    0
+  end
+
+  def shutdown(*)
+    close
+  end
+
+  def to_io
+    self
+  end
+
+  def wait_readable(_timeout = nil)
+    respond_to?(:__nimbus_socket_ready?) && __nimbus_socket_ready? ? self : nil
+  end
+
+  def wait_writable(_timeout = nil)
+    closed? ? nil : self
+  end
+end unless defined?(::BasicSocket)
+
+class IPSocket < BasicSocket
+  def addr
+    ['AF_INET', @local_port || 0, @local_host || '0.0.0.0', @local_host || '0.0.0.0']
+  end
+
+  def peeraddr
+    ['AF_INET', @remote_port || 0, @remote_host || '127.0.0.1', @remote_host || '127.0.0.1']
+  end
+
+  def local_address
+    Addrinfo.new(@local_host || '0.0.0.0', @local_port || 0)
+  end
+
+  def remote_address
+    Addrinfo.new(@remote_host || '127.0.0.1', @remote_port || 0)
+  end
+end unless defined?(::IPSocket)
+
+class Socket < BasicSocket
+  AF_INET = 2 unless const_defined?(:AF_INET)
+  AF_INET6 = 10 unless const_defined?(:AF_INET6)
+  SOCK_STREAM = 1 unless const_defined?(:SOCK_STREAM)
+  SOL_SOCKET = 1 unless const_defined?(:SOL_SOCKET)
+  SO_REUSEADDR = 2 unless const_defined?(:SO_REUSEADDR)
+  IPPROTO_TCP = 6 unless const_defined?(:IPPROTO_TCP)
+  TCP_NODELAY = 1 unless const_defined?(:TCP_NODELAY)
+  AI_PASSIVE = 1 unless const_defined?(:AI_PASSIVE)
+
+  def self.gethostname
+    'nimbus'
+  end
+
+  def self.getaddrinfo(host, port, *_)
+    [[AF_INET, port.to_i, host || '0.0.0.0', host || '0.0.0.0', AF_INET, SOCK_STREAM, IPPROTO_TCP]]
+  end
+
+  def self.tcp_server_sockets(address, port)
+    [TCPServer.new(address || '0.0.0.0', port)]
+  end
+end unless defined?(::Socket)
+
+# Ruby's socket API hands addresses back as Addrinfo, and callers print them.
+class Addrinfo
+  attr_reader :ip_address, :ip_port
+
+  def initialize(host, port)
+    @ip_address = host.to_s
+    @ip_port = port.to_i
+  end
+
+  def inspect_sockaddr
+    @ip_address.include?(':') ? "[#{@ip_address}]:#{@ip_port}" : "#{@ip_address}:#{@ip_port}"
+  end
+  alias to_s inspect_sockaddr
+
+  def afamily
+    Socket::AF_INET
+  end
+  alias pfamily afamily
+
+  def ip?
+    true
+  end
+
+  def ipv4?
+    true
+  end
+
+  def ipv6?
+    false
+  end
+
+  def getnameinfo(*)
+    [@ip_address, @ip_port.to_s]
+  end
+end unless defined?(::Addrinfo)
+
+# A listening socket is a descriptor whose read is accept(2): it parks until a
+# connection is queued and yields that connection. So an ordinary stdlib accept
+# loop works, and every server - a hand-written TCPServer, Rack, WEBrick - runs
+# on the same code with no adapter and no knowledge of any particular library.
+class TCPServer < IPSocket
+  # for_fd is standard Ruby: reconstruct a listening socket from a descriptor.
+  # The descriptor is the identity, so the same object is handed back.
+  @@__nimbus_by_fd = {}
+
+  def self.for_fd(fd)
+    server = @@__nimbus_by_fd[fd.to_i]
+    raise Errno::EBADF, "not a Nimbus listening socket: #{fd}" unless server
+    server
+  end
+
+  def initialize(host_or_port, port = nil)
+    @local_host = port.nil? ? '0.0.0.0' : host_or_port.to_s
+    # Bind first: port 0 means "pick one", and only the kernel knows which.
+    @local_port = Nimbus::VirtualSocket.listen((port || host_or_port).to_i)
+    @io = File.open("/dev/nimbus/listen/#{@local_port}", File::RDONLY)
+    # Listening is what makes this process host-driven: from here on inbound
+    # requests are what resume it, so the scheduler waits on the host's clock
+    # rather than stopping the world in a wall-clock sleep.
+    Nimbus::Threading.host_driven = true
+    @@__nimbus_by_fd[@io.fileno] = self
+  end
+
+  def __nimbus_virtual_port
+    @local_port
+  end
+
+  def fileno
+    @io.fileno
+  end
+
+  # Ruby servers reach for to_io to get at the "real" socket; this IS the real
+  # socket, and handing back the bare descriptor would lose accept.
+  def to_io
+    self
+  end
+
+  def addr
+    ['AF_INET', @local_port, @local_host, @local_host]
+  end
+
+  def local_address
+    Addrinfo.new(@local_host, @local_port)
+  end
+  alias connect_address local_address
+
+  # Blocks until a connection arrives, by parking the process rather than the
+  # wasm stack. A workerd request context cannot resume a stack another request
+  # suspended, so a JSPI-level block here would serve exactly one request and
+  # then hang; a fiber park survives, because its state is Ruby's own.
+  def accept
+    loop do
+      return connect_accepted(@io.gets) if __nimbus_socket_ready?
+      raise IOError, 'closed stream' if closed?
+      Nimbus::VirtualSocket.park(-> { __nimbus_socket_ready? })
+    end
+  end
+
+  def accept_nonblock(exception: true)
+    unless __nimbus_socket_ready?
+      return :wait_readable unless exception
+      raise IO::EAGAINWaitReadable
+    end
+    connect_accepted(@io.gets)
+  end
+
+  def __nimbus_socket_ready?
+    !closed? && Nimbus::VirtualSocket.pending(@local_port) > 0
+  end
+
+  def listen(_backlog = nil)
+    0
+  end
+
+  # POSIX autoclose: with it cleared the descriptor - and so the listener -
+  # outlives this object. Servers rely on that when they re-wrap a listening
+  # socket with for_fd and drop the original.
+  def close
+    return nil if closed? || @autoclose == false
+    @@__nimbus_by_fd.delete(@io.fileno)
+    Nimbus::VirtualSocket.close_listener(@local_port)
+    @io.close
+    nil
+  end
+
+  def closed?
+    @io.closed?
+  end
+
+  private
+
+  def connect_accepted(line)
+    id = line.to_s.strip
+    raise IOError, 'closed stream' if id.empty?
+    TCPSocket.__nimbus_from_connection(id.to_i, @local_host, @local_port, '127.0.0.1', 0)
+  end
+end unless defined?(::TCPServer)
+
+# One socket class, one transport: a WASI file descriptor.
+#
+# fd_read and fd_write are WebAssembly.Suspending imports and Ruby's eval
+# entrypoint runs under WebAssembly.promising, so a read genuinely parks the
+# wasm stack until bytes arrive and then resumes. That makes a Nimbus socket an
+# ordinary IO, which is why there is no buffering, framing or blocking logic
+# here - Ruby's own IO layer supplies all of it.
+#
+# A DIALED socket opens /dev/tcp/<host>/<port>. An ACCEPTED one is bound to a
+# descriptor by the kernel when the cooperative pump hands the connection over.
+# Both are the same kind of fd, so both are the same code below.
+class TCPSocket < IPSocket
+  # Everything a stream socket does IS what an IO does. Delegating rather than
+  # reimplementing is what keeps this class from growing a second, subtly
+  # different set of socket semantics.
+  IO_METHODS = %i[
+    read readpartial read_nonblock readline readlines readchar readbyte
+    write write_nonblock print printf putc puts
+    gets each_line getc getbyte ungetbyte ungetc
+    eof eof? flush fsync sync sync= fileno binmode
+    close_read close_write external_encoding set_encoding
+  ].freeze
+
+  IO_METHODS.each do |name|
+    define_method(name) { |*args, **kwargs, &block| @io.public_send(name, *args, **kwargs, &block) }
+  end
+
+  def self.__nimbus_from_connection(id, local_host, local_port, remote_host, remote_port)
+    socket = allocate
+    socket.send(:initialize_nimbus, File.open("/dev/nimbus/socket/#{id.to_i}", File::RDWR),
+                local_host, local_port, remote_host, remote_port)
+    socket
+  end
+
+  def initialize(host = nil, port = nil, local_host = nil, local_port = nil)
+    remote_host = (host || '127.0.0.1').to_s
+    remote_port = port.to_i
+    begin
+      io = File.open("/dev/tcp/#{remote_host}/#{remote_port}", File::RDWR)
+    rescue SystemCallError => e
+      detail = Nimbus::VirtualSocket.last_socket_error
+      message = "Nimbus could not dial #{remote_host}:#{remote_port}: #{e.message}"
+      message += " (#{detail})" unless detail.empty?
+      raise ::SocketError, message
+    end
+    initialize_nimbus(io, local_host ? local_host.to_s : '0.0.0.0', local_port.to_i, remote_host, remote_port)
+  end
+
+  # Without this, TCPSocket.open - which is how Net::HTTP opens a connection -
+  # falls through to the private Kernel#open and reports that instead of
+  # anything about sockets.
+  def self.open(*args, &block)
+    socket = new(*args)
+    return socket unless block
+    begin
+      block.call(socket)
+    ensure
+      socket.close
+    end
+  end
+
+  def initialize_nimbus(io, local_host, local_port, remote_host, remote_port)
+    @io = io
+    # Unbuffered writes: a request that sits in Ruby's write buffer never
+    # reaches the peer, and this socket has no separate flush point.
+    @io.sync = true
+    @local_host = local_host
+    @local_port = local_port.to_i
+    @remote_host = remote_host
+    @remote_port = remote_port.to_i
+  end
+
+  def to_io
+    @io
+  end
+
+  def __nimbus_socket_ready?
+    !@io.closed?
+  end
+
+  def <<(data)
+    @io.write(data)
+    self
+  end
+
+  def close
+    @io.close unless @io.closed?
+    nil
+  end
+
+  def closed?
+    @io.closed?
+  end
+end unless defined?(::TCPSocket)
+
+class << IO
+  unless method_defined?(:__nimbus_original_select)
+    alias_method :__nimbus_original_select, :select
+  end
+
+  # select is two waits wearing one name, and a timeout is load-bearing in
+  # both: waiting for a Nimbus socket to become readable, and waiting for
+  # nothing at all, which is how a great deal of stdlib code spells sleep. Both
+  # go through the scheduler, because a caller that waits by watching the clock
+  # here never gets to see it move.
+  def select(reads, writes = nil, errors = nil, timeout = nil)
+    read_list = Array(reads)
+    write_list = Array(writes)
+    error_list = Array(errors)
+    if read_list.empty? && write_list.empty? && error_list.empty?
+      Kernel.sleep(timeout)
+      return nil
+    end
+    virtual_reads = read_list.select { |io| io.respond_to?(:__nimbus_socket_ready?) }
+    if virtual_reads.any?
+      deadline = timeout ? Time.now + timeout : nil
+      loop do
+        ready = virtual_reads.select { |io| io.__nimbus_socket_ready? }
+        return [ready, write_list, []] if ready.any?
+        return nil if deadline && Time.now >= deadline
+        Nimbus::VirtualSocket.park(
+          -> { virtual_reads.any? { |io| io.__nimbus_socket_ready? } }, deadline
+        )
+      end
+    end
+    __nimbus_original_select(reads, writes, errors, timeout)
+  end
+end
+
+module Kernel
+  # Kernel#require is PRIVATE, so method_defined? is always false here and a
+  # second application of this shim would alias the override onto itself and
+  # recurse until SystemStackError.
+  unless private_method_defined?(:__nimbus_original_require)
+    alias_method :__nimbus_original_require, :require
+  end
+
+  def require(path)
+    if path == 'socket'
+      $LOADED_FEATURES << 'socket.rb' unless $LOADED_FEATURES.include?('socket.rb')
+      return false
+    end
+    if path == 'io/nonblock'
+      $LOADED_FEATURES << 'io/nonblock.rb' unless $LOADED_FEATURES.include?('io/nonblock.rb')
+      return false
+    end
+    if path == 'io/wait'
+      $LOADED_FEATURES << 'io/wait.rb' unless $LOADED_FEATURES.include?('io/wait.rb')
+      return false
+    end
+    loaded = __nimbus_original_require(path)
+    Nimbus::Threading.install_timeout_shim if path == 'timeout' || path.start_with?('net/')
+    loaded
+  end
+end
+
+$LOADED_FEATURES << 'socket.rb' unless $LOADED_FEATURES.include?('socket.rb')
+Nimbus::Threading.install_timeout_shim
+`;

package/dist/runtime/session-process-supervisor.d.ts

@@ -0,0 +1,156 @@
+/**
+ * SessionProcessSupervisor — the session's single process owner.
+ *
+ * Deep-module facade over the three process storage primitives:
+ *
+ *   - ProcessTable      — PID authority and lifecycle state.
+ *   - ProcessInputStore — controlling-terminal input channel: stdin
+ *     packets, resize (coalesced), signals, terminal size.
+ *   - ProcessLogStore   — bounded output rings, exit records, and the
+ *     SQL-backed hibernation persistence (W9).
+ *
+ * Every session-side caller — session routes, the programmatic SDK RPC
+ * surface, agent tools, shell commands, npm-bin launches, the
+ * child-process broker, and runtime runners — goes through this facade.
+ * No caller touches the underlying stores directly.
+ *
+ * Stage 2 of the OS kernel plan (docs/architecture/nimbus-os-runtime-spec.md,
+ * "Process And PTY Completion") extends this module with process groups,
+ * raw/cooked terminal mode, and foreground-process-group signal policy.
+ * `ProcessTerminalDescriptor` is the seam those land on.
+ */
+import { ProcessTable, type ProcessEntry } from './process-table.js';
+import { type ProcessInputPacket } from './process-input.js';
+import { ProcessLogStore, type LogChunk, type LogStream, type PersistAdapter, type ProcessExitInfo, type ProcessLogReadOptions, type SequencedLogChunk } from './process-logs.js';
+import type { ProcessSignalName } from './process-io-protocol.js';
+import type { VfsCred } from './os-contracts.js';
+export interface ProcessSpawnOptions {
+    /** Long-lived process (dev server, watcher, attached CLI). Surfaces a process tab. */
+    longRunning?: boolean;
+    /** Output and stdin are owned by an attached process terminal, not the parent shell. */
+    attachedTty?: boolean;
+    /** Inherit the parent process credential, including its current umask. */
+    parentPid?: number;
+    /** Explicit credential for a deliberate identity transition such as sudo. */
+    cred?: VfsCred;
+}
+/**
+ * Controlling-terminal descriptor for a process with an open input
+ * channel. Folds the `attachedTty` classification and the input
+ * channel's terminal size into one typed view. Stage 2 adds raw/cooked
+ * mode state and the foreground process group here.
+ */
+export interface ProcessTerminalDescriptor {
+    pid: number;
+    /** True when the process runs as an attached TTY-shaped process tab. */
+    attached: boolean;
+    columns: number;
+    rows: number;
+}
+export declare class SessionProcessSupervisor {
+    private readonly table;
+    private readonly input;
+    private logs;
+    /** Terminators for processes whose work is a promise this session owns. */
+    private terminators;
+    /** Fires after every appendOutput/markExit once log persistence is wired. */
+    private logActivity;
+    /** Allocate a PID and register a new process. */
+    spawn(command: string, argv: string[], cwd: string, opts?: ProcessSpawnOptions): ProcessEntry;
+    /** Mark an existing entry as long-running. Idempotent. */
+    setLongRunning(pid: number): void;
+    /** Mark an existing entry as an attached terminal process. Idempotent. */
+    setAttachedTty(pid: number): void;
+    get(pid: number): ProcessEntry | undefined;
+    getRunning(): ProcessEntry[];
+    getAll(): ProcessEntry[];
+    /** Every process spawned under `pid`, transitively, oldest first. */
+    descendantsOf(pid: number): ProcessEntry[];
+    /**
+     * Register how to stop the work behind `pid`. Background jobs started
+     * through the programmatic API run as a promise held by this session, so
+     * `kill` has to abort them rather than only marking the table entry.
+     * Cleared once the process reaches a terminal state.
+     */
+    setTerminator(pid: number, terminate: () => void): void;
+    private terminate;
+    cred(pid: number): VfsCred;
+    setUmask(pid: number, umask: number): number;
+    /** Mark a process as exited. First terminal state wins. */
+    exit(pid: number, exitCode: number): void;
+    /**
+     * Mark a process as killed and tear down its input channel so queued
+     * stdin can't outlive the process.
+     */
+    kill(pid: number): boolean;
+    /** Clean up exited processes older than maxAge ms. */
+    reap(maxAge?: number): number;
+    get stats(): ProcessTable['stats'];
+    /** See ProcessTable.setPidBase — generation-unique pid allocation. */
+    setPidBase(base: number): void;
+    /** The current generation's pid floor: pids <= base are prior-generation. */
+    get pidBase(): number;
+    /** Open the process's input channel. Until opened, input writes fail. */
+    openInput(pid: number): void;
+    hasInput(pid: number): boolean;
+    writeInput(pid: number, data: string): {
+        ok: boolean;
+    };
+    /** Signal stdin EOF. Queued packets still drain; further writes fail. */
+    endInput(pid: number): void;
+    /** End and drop the input channel entirely. */
+    closeInput(pid: number): void;
+    readInput(pid: number, waitMs?: number): Promise<ProcessInputPacket>;
+    resize(pid: number, columns: number, rows: number): {
+        ok: boolean;
+    };
+    signal(pid: number, signal: ProcessSignalName): {
+        ok: boolean;
+    };
+    /** Controlling-terminal descriptor; null when no input channel is open. */
+    terminal(pid: number): ProcessTerminalDescriptor | null;
+    appendOutput(pid: number, stream: LogStream, data: string): void;
+    /** Record exit in the log store. Idempotent: the first record wins. */
+    markExit(pid: number, code: number, reason?: string): void;
+    getExit(pid: number): ProcessExitInfo | null;
+    hasLogs(pid: number): boolean;
+    logSize(pid: number): number;
+    readLogs(pid: number, opts?: ProcessLogReadOptions): {
+        chunks: SequencedLogChunk[];
+        cursor: number;
+        truncated: boolean;
+    };
+    tailLogs(pid: number, opts?: Pick<ProcessLogReadOptions, 'lines' | 'bytes'>): LogChunk[];
+    allLogs(pid: number): LogChunk[];
+    /** See ProcessLogStore.buffered — a read that never hydrates from SQL. */
+    bufferedLogs(pid: number): LogChunk[];
+    logSnapshot(pid: number): {
+        bytes: number;
+        chunks: number;
+        exit: ProcessExitInfo | null;
+    } | null;
+    subscribeLogs(pid: number, cb: (chunk: LogChunk) => void): () => void;
+    subscribeExit(pid: number, cb: (exit: ProcessExitInfo) => void): () => void;
+    get logStats(): ProcessLogStore['stats'];
+    /**
+     * Install the SQL-backed persistence adapter. `onActivity` fires after
+     * every appendOutput/markExit so the host can schedule debounced
+     * flushes without the store knowing about timers.
+     */
+    setLogPersist(adapter: PersistAdapter, onActivity: () => void): void;
+    /**
+     * Install the instance-level chunk/exit broadcast (the hibernation-safe
+     * process-terminal WS fan-out — see ProcessLogStore.setBroadcast).
+     */
+    setLogBroadcast(onChunk: (pid: number, chunk: LogChunk) => void, onExit: (pid: number, exit: ProcessExitInfo) => void): void;
+    flushLogs(): void;
+    dropLogsOlderThan(ageMs?: number, isOrphan?: (pid: number) => boolean): number;
+    logHibStats(): ReturnType<ProcessLogStore['hibStats']>;
+    /**
+     * Replace the in-memory log store with a fresh, unwired one. Test-only
+     * hibernation simulation (`/api/_test/hib/simulate`): the caller must
+     * re-wire persistence afterwards, mirroring a post-wake isolate.
+     */
+    resetLogStore(): void;
+}
+//# sourceMappingURL=session-process-supervisor.d.ts.map