@solidrt/flux-types 0.0.34 → 0.0.36

package/gui/gpu.d.ts

@@ -20,7 +20,23 @@ declare module "flux:gpu" {
    * (default 0) selects which frame to upload.
    */
   export function uploadTexture(id: number, data: Uint8Array, offset?: number): void
-  /** Destroy a texture (immutable, mutable, or shader). */
+  /**
+   * Replace a texture's storage with a new size at the same id (an id-stable
+   * resize): `<texture src>` references and shader sampler bindings keep
+   * working, and shaders sampling the texture re-render. `data` seeds the new
+   * contents and, like {@link createMutableTexture}, must hold at least one
+   * width*height*4 frame. Shader/pipeline target ids are rejected - resize
+   * those with {@link setShaderSize}.
+   */
+  export function resizeTexture(id: number, data: Uint8Array, width: number, height: number): void
+  /**
+   * Destroy a texture (immutable, mutable, or shader). Frame-safe: the id is
+   * reclaimed by the runtime once the render tree no longer references it, so
+   * destroying the old id in the same update that repoints `<texture src>` at
+   * its replacement never paints a blank frame, whatever order the two land
+   * in. A destroyed id that stays mounted keeps drawing (and stays allocated)
+   * until it is unmounted or repointed.
+   */
   export function destroyTexture(id: number): void
   /**
    * Compile a GLSL ES fragment shader into an offscreen texture of the given
@@ -36,6 +52,23 @@ declare module "flux:gpu" {
   ): number
   /** Update a shader texture's float uniforms by name and re-render it. */
   export function setShaderParams(id: number, params: Record<string, number>): void
+  /**
+   * Rebind a shader texture's sampler2D inputs by uniform name and re-render
+   * it with its last-applied params - the sampler analog of
+   * {@link setShaderParams}. Bindings not named keep their current source, so
+   * a single input can be retargeted (post-process source swap, ping-pong
+   * between two data textures) without recompiling the shader. Throws if the
+   * shader or a source texture id is unknown, or a sampler would source the
+   * shader's own target.
+   */
+  export function setShaderTextures(id: number, textures: Record<string, number>): void
+  /**
+   * Resize a shader or pipeline target texture in place and re-render it: the
+   * id, compiled program, last-applied params, and sampler bindings all carry
+   * over; only the output size changes. The setDrawCount analog for output
+   * size.
+   */
+  export function setShaderSize(id: number, width: number, height: number): void
 
   export type Topology = "points" | "lines" | "line-strip" | "triangles" | "triangle-strip"
   /**

package/gui/rendertree.d.ts

@@ -46,8 +46,16 @@ declare module "flux:rendertree" {
    */
   export function measureText(text: string, options?: MeasureTextOptions): { width: number, height: number }
   /**
-   * The node's window-relative bounding box from the most recent layout, or
-   * `null` if it has no layout or has not been laid out yet.
+   * The node's bounding box from the most recent layout, relative to its
+   * nearest positioning context (an ancestor with an explicit
+   * `position="relative"`, falling back to the window), or `null` if it has no
+   * layout or has not been laid out yet. Transforms anywhere in the chain
+   * compose fully; the box is the axis-aligned bounds of the transformed quad.
    */
   export function getBoundingBox(id: number): { x: number, y: number, width: number, height: number } | null
+  /**
+   * Like getBoundingBox, but always window-relative (getBoundingClientRect
+   * semantics), for comparing against pointer event coordinates.
+   */
+  export function getBoundingBoxViewport(id: number): { x: number, y: number, width: number, height: number } | null
 }

package/modules/http.d.ts

@@ -99,7 +99,7 @@ declare module "flux:http" {
      * The peer's IP address (or, for a connection accepted over the `p2p`
      * option, the peer's endpoint id), or undefined when unknown.
      */
-    readonly remoteAddress: string | undefined
+    readonly remoteAddr: string | undefined
   }
 
   /**
@@ -151,8 +151,8 @@ declare module "flux:http" {
   type Server = {
     /** The bound port. */
     readonly port: number
-    /** The bound hostname/interface. */
-    readonly hostname: string
+    /** The bound host/interface. */
+    readonly host: string
     /** The server's base URL, e.g. `"http://0.0.0.0:3000/"`. */
     readonly url: string
     /**
@@ -179,7 +179,7 @@ declare module "flux:http" {
      * Stop accepting new connections and gracefully shut down open ones. Safe to
      * call more than once.
      */
-    stop(): void
+    close(): void
   }
 
   /** Options for accepting `flux:p2p` connections alongside the TCP listener. */
@@ -194,7 +194,7 @@ declare module "flux:http" {
     /** Port to listen on. */
     port: number
     /** Hostname/interface to bind. Defaults to "0.0.0.0" (all interfaces). */
-    hostname?: string
+    host?: string
     /**
      * Route table keyed by path pattern. Patterns may contain `:name` segments,
      * exposed on `req.params`. Each value is a handler function, a static
@@ -219,7 +219,7 @@ declare module "flux:http" {
     /**
      * Accept connections on a `flux:p2p` Endpoint alongside the TCP listener:
      * each incoming connection whose ALPN matches `protocol` has the HTTP/WS
-     * protocol spoken over its first bidirectional stream. `server.stop()`
+     * protocol spoken over its first bidirectional stream. `server.close()`
      * stops accepting; the endpoint itself stays open for its owner.
      */
     p2p?: P2pOptions
@@ -228,7 +228,7 @@ declare module "flux:http" {
   /**
    * Start an HTTP server. Loosely models Bun's `Bun.serve`.
    *
-   * @param options  Port, hostname, routes, fetch fallback, error handler, and
+   * @param options  Port, host, routes, fetch fallback, error handler, and
    *                 websocket callbacks.
    * @returns The running {@link Server}.
    */

package/modules/net.d.ts

@@ -67,32 +67,46 @@ declare module "flux:net" {
    */
   export class Conn implements AsyncIterable<Uint8Array> {
     /** The remote peer's address, e.g. "192.168.2.37:445". */
-    readonly peer: string
+    readonly remoteAddr: string
     /** Write all of `data`. Resolves once it is handed to the OS. */
     write(data: string | Uint8Array): Promise<void>
-    /** Stop reading and close the connection. */
+    /**
+     * Half-close: flush and end the write side, so the peer sees end-of-stream
+     * while this side keeps reading until the peer closes. The way to signal
+     * "request done" to protocols that answer after EOF. After it, {@link write}
+     * throws. Idempotent, and a no-op once the connection is closed.
+     */
+    closeWrite(): Promise<void>
+    /**
+     * Close the connection now: a pending read ends, the peer sees end-of-stream
+     * at once. Bytes already handed to the OS still flush.
+     */
     close(): void
     [Symbol.asyncIterator](): AsyncIterator<Uint8Array>
   }
 
   /**
    * A bound TCP listener: an async-iterable of incoming connections, so
-   * `for await (let conn of listener)` accepts them. Drop it to stop.
+   * `for await (let conn of listener)` accepts them. `close()` to stop.
    */
   export class Listener implements AsyncIterable<Conn> {
-    /** The bound local address (with the OS-assigned port when 0 was requested). */
+    /** The bound local address (with the OS-assigned port when 0 was requested). Empty once closed. */
     readonly localAddr: string
+    /** Close the listener: release the port and end the iteration. */
+    close(): void
     [Symbol.asyncIterator](): AsyncIterator<Conn>
   }
 
   /** A bound UDP socket with the broadcast/multicast controls a peer beacon needs. */
   export class Udp {
-    /** The bound local address (with the OS-assigned port when 0 was requested). */
+    /** The bound local address (with the OS-assigned port when 0 was requested). Empty once closed. */
     readonly localAddr: string
     /** Send a datagram to `host:port` — a unicast peer, a broadcast address, or a multicast group. */
     send(data: string | Uint8Array, host: string, port: number): Promise<void>
-    /** Receive the next datagram. */
-    recv(): Promise<Datagram>
+    /** Receive the next datagram, or `null` once the socket is closed. */
+    recv(): Promise<Datagram | null>
+    /** Close the socket: release it (and its bound port) and resolve a pending {@link recv} with `null`. */
+    close(): void
     /** Allow sending to the broadcast address (SO_BROADCAST). */
     setBroadcast(on: boolean): void
     /** TTL for outgoing multicast (1 keeps it on the local link). */
@@ -108,6 +122,17 @@ declare module "flux:net" {
     leaveMulticast(group: string, iface?: string): void
   }
 
+  /**
+   * Outcome of an {@link icmpEcho}. Infallible like {@link probe}: `timeout`
+   * covers every "no evidence" case (no reply, unreachable, resolve failure);
+   * `unsupported` means this platform/configuration has no unprivileged ICMP
+   * socket, so "host silent" and "cannot ask" stay distinguishable.
+   */
+  type IcmpEchoResult =
+    | { status: "reply"; rttMs: number; payload: Uint8Array }
+    | { status: "timeout" }
+    | { status: "unsupported" }
+
   /**
    * Probe `host:port` with a TCP connect and report what it says about the host.
    * Infallible — every outcome maps to a {@link Liveness}, so a sweep never has to
@@ -131,6 +156,14 @@ declare module "flux:net" {
   /** Bind a {@link Udp} socket. */
   export function udp(opts?: UdpOptions): Promise<Udp>
 
+  /**
+   * Ping `host` once: send an ICMP echo request carrying `payload` (default
+   * empty) and wait for the matching reply. IPv4 only.
+   *
+   * @param opts  timeoutMs (default 1000).
+   */
+  export function icmpEcho(host: string, payload?: string | Uint8Array, opts?: ConnectOptions): Promise<IcmpEchoResult>
+
   /**
    * Enumerate local network interfaces and their addresses — the no-subprocess
    * way to find the subnet to scan (replaces parsing `ip addr`). Synchronous.

package/modules/p2p.d.ts

@@ -55,9 +55,9 @@ declare module "flux:p2p" {
     readonly remoteId: string
     /** Queue bytes on the send half. */
     write(data: string | Uint8Array): void
-    /** Finish the send half (QUIC FIN) after queued writes flush. The recv half stays open. */
-    finish(): void
-    /** Tear the stream down: finish the send half and stop reading. */
+    /** Half-close: end the send half (QUIC FIN) after queued writes flush. The recv half stays open. */
+    closeWrite(): void
+    /** Tear the stream down: end the send half and stop reading. */
     close(): void
     [Symbol.asyncIterator](): AsyncIterator<Uint8Array>
   }

package/modules/sqlite.d.ts

@@ -34,7 +34,7 @@ declare module "flux:sqlite" {
      * @param path  Database file path.
      * @param mode  Open mode; defaults to "ro".
      */
-    static connect(path: string, mode?: OpenMode): Promise<Database>
+    static open(path: string, mode?: OpenMode): Promise<Database>
     /** Create a reusable prepared statement (synchronous; compiles on first run). */
     query(sql: string): Statement
     /** One-shot write; uses plain prepare (no caching). */

package/modules/subprocess.d.ts

@@ -50,8 +50,8 @@ declare module "flux:subprocess" {
     stderr: AsyncIterable<Uint8Array>
     /** Queue bytes to the child's stdin. Writes serialize and respect backpressure. */
     write(data: string | Uint8Array): Promise<void>
-    /** Close the child's stdin (after queued writes drain) so it sees EOF. */
-    endStdin(): Promise<void>
+    /** Half-close: close the child's stdin (after queued writes drain) so it sees EOF. */
+    closeWrite(): Promise<void>
     /** Request termination (portable; SIGKILL / TerminateProcess). */
     kill(): void
     /** Resolves with the exit status when the child exits. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidrt/flux-types",
-  "version": "0.0.34",
+  "version": "0.0.36",
   "license": "MIT",
   "author": "Antoine van Wel",
   "types": "index.d.ts",