@solidrt/flux-types 0.0.52 → 0.0.54

package/gui/gpu.d.ts

@@ -740,6 +740,22 @@ declare module "flux:gpu" {
    * alone.
    * Returns a texture id (display, resize, destroy like any target; entries
    * die with it).
+   *
+   * `into` makes a SUB-TARGET: a draw target that renders into the `width`
+   * x `height` rectangle at `x`/`y` (top-left origin, the texture leaf's
+   * `srcX`/`srcY` space; default 0) of draw target `into`'s storage instead
+   * of owning any. It is a draw target to every verb - entries, shared
+   * params and bindings, order, `setTargetSize` - with dirty state of its
+   * own, and the parent renders ALL its tiles in ONE pass: a changed tile
+   * redraws over its own rectangle (the rest keeps its pixels), a changed
+   * parent redraws everything. That is what makes N views or N shadow maps
+   * cost one pass instead of N. The returned id is not a texture: sample,
+   * display (`<d-texture src={parent} srcX srcY srcW srcH>`), read back and
+   * copy the PARENT; `depthTexture(parent)` is the tile's depth too. Depth,
+   * `samples`, `render` and `loadOp` are the parent's (passing them
+   * throws), `clearColor` is the tile's own. A rectangle partly outside the
+   * parent is clipped; {@link setTargetRect} moves it. Tiles do not nest.
+   * Destroying the parent destroys its tiles.
    */
   export function createDrawTarget(
     width: number,
@@ -752,6 +768,9 @@ declare module "flux:gpu" {
       render?: "auto" | "manual"
       loadOp?: "clear" | "load"
       samples?: 1 | 2 | 4 | 8
+      into?: TextureId
+      x?: number
+      y?: number
     } & SamplerOptions &
       LabelOption,
   ): TextureId
@@ -890,6 +909,14 @@ declare module "flux:gpu" {
    * which carries seed pixels instead.)
    */
   export function setTargetSize(id: TextureId, width: number, height: number): void
+  /**
+   * Move and resize a sub-target's rectangle in its parent (top-left
+   * origin; every key required). The parent re-renders in full at the next
+   * flush. Throws for anything but a sub-target (see `into` on
+   * {@link createDrawTarget}); `setTargetSize` on a tile is this with the
+   * origin kept.
+   */
+  export function setTargetRect(id: TextureId, rect: { x: number; y: number; width: number; height: number }): void
   /**
    * Rebind one draw entry's sampler2D inputs by uniform name:
    * {@link setTargetTextures} addressed to a single entry, same merge,

package/gui/rendertree.d.ts

@@ -87,7 +87,11 @@ declare module "flux:rendertree" {
   export function setRoot(id: number): void
   /** Create a node of `kind` (the primitive element name) with the given id. Throws an `Error` for a name that is not an element. */
   export function createNode(id: number, kind: string): void
-  /** Insert `nodeId` under `parentId`, before `anchorId` if given (else appended). */
+  /**
+   * Insert `nodeId` under `parentId`, before `anchorId` if given (else appended).
+   * Throws an `Error` when a laid-out node would land under a detached (d-*)
+   * parent: a detached subtree is entirely detached. The tree is left untouched.
+   */
   export function insertNode(parentId: number, nodeId: number, anchorId?: number): void
   /**
    * Unlink `nodeId` from `parentId` but keep its subtree alive, so it can be

package/modules/image.d.ts

@@ -1,24 +1,47 @@
 declare module "flux:image" {
-  /** Decoded pixels: tightly-packed RGBA8 plus the pixel dimensions. */
+  /**
+   * Decoded pixels: tightly-packed RGBA8 plus the pixel dimensions. Alpha is
+   * premultiplied unless the call that produced them said otherwise.
+   */
   export type DecodedImage = {
     data: Uint8Array
     width: number
     height: number
   }
 
+  /**
+   * Which alpha convention a pixel buffer follows. Image files store
+   * `"straight"` alpha; every texture and target on the GPU is
+   * `"premultiplied"` (color already multiplied by alpha), and so is what
+   * `readTexture` / `captureSnapshot` hand back.
+   */
+  export type AlphaMode = "premultiplied" | "straight"
+
   /**
    * Decodes encoded image bytes (png, jpeg, webp, gif, bmp, ico) into raw
    * RGBA8 pixels plus the decoded dimensions. Synchronous, pure CPU. Throws
    * when the bytes are not a decodable image.
+   *
+   * `alpha` selects what comes out: `"premultiplied"` (default) is ready for
+   * `createTexture` as-is; `"straight"` is the file's pixels verbatim, for CPU
+   * processing that wants color under transparent pixels preserved. Opaque
+   * pixels are identical either way.
    */
-  export function decodeImage(bytes: Uint8Array): DecodedImage
+  export function decodeImage(bytes: Uint8Array, options?: { alpha?: AlphaMode }): DecodedImage
 
   /**
    * Encodes raw RGBA8 pixels into an image file, the reverse of `decodeImage`
-   * (`encodeImage(decodeImage(bytes))` round-trips). `format` defaults to
-   * `"png"` (lossless, keeps alpha); `"jpeg"` drops the alpha channel and
-   * takes `quality` in 0..1 (default 0.9, ignored for png). Throws when
-   * `data.length` does not match `width * height * 4`.
+   * (`encodeImage(decodeImage(bytes))` round-trips: exactly for opaque and
+   * fully transparent pixels, within rounding for translucent ones). `format`
+   * defaults to `"png"` (lossless, keeps alpha); `"jpeg"` drops the alpha
+   * channel and takes `quality` in 0..1 (default 0.9, ignored for png).
+   * `alpha` names what `img.data` holds: `"premultiplied"` (default, a decode
+   * or a readback) is converted to the straight alpha PNG stores;
+   * `"straight"` is written verbatim. Throws when `data.length` does not
+   * match `width * height * 4`.
    */
-  export function encodeImage(img: DecodedImage, options?: { format?: "png" | "jpeg"; quality?: number }): Uint8Array
+  export function encodeImage(
+    img: DecodedImage,
+    options?: { format?: "png" | "jpeg"; quality?: number; alpha?: AlphaMode },
+  ): Uint8Array
 }

package/modules/net.d.ts

@@ -22,6 +22,10 @@ declare module "flux:net" {
   /**
    * Outcome of a {@link probe}. `closed` (a refusal) still means the host is up —
    * something answered; only `filtered` (a timeout/unreachable) is no evidence.
+   *
+   * Windows reports a refusal only after ~2 s of SYN retries, so a `timeoutMs`
+   * under that reads a refused port as `filtered` there; `open` is instant
+   * everywhere.
    */
   type Liveness = "open" | "closed" | "filtered"
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidrt/flux-types",
-  "version": "0.0.52",
+  "version": "0.0.54",
   "license": "MIT",
   "funding": "https://github.com/sponsors/wellawaretech",
   "author": "Antoine van Wel",