@solidrt/flux-types 0.0.50 → 0.0.51

package/gui/audio.d.ts

@@ -1,7 +1,10 @@
-// Sound playback (gui-enabled runtime only). The imperative primitive; `play`
-// decodes and starts a clip in one call, while `load`/`loadPcm`/`stream` yield
-// a Clip that starts cheap overlapping Playbacks. Handles carry controls bound
-// to just that clip or playback, so raw ids never leave the runtime.
+// Sound playback (gui-enabled runtime only: feature-detect with
+// `Flux.capabilities.includes("audio")` before importing on a runtime that may
+// lack it - a static import fails at module load there). The imperative
+// primitive; `play` decodes and starts a clip in one call, while
+// `load`/`loadPcm`/`stream` yield a Clip that starts cheap overlapping
+// Playbacks. Handles carry controls bound to just that clip or playback, so
+// raw ids never leave the runtime.
 
 declare module "flux:audio" {
   /** Options for {@link play} and {@link Clip.play}. */
@@ -16,31 +19,97 @@ declare module "flux:audio" {
      * all, which for a mono clip is about 3 dB louder than `pan: 0`.
      */
     pan?: number
+    /**
+     * Playback rate: 1.0 plays as loaded, higher is faster and higher-pitched,
+     * lower slower and deeper (a plain resample, no formant correction).
+     * Clamped to [0.01, 100]. Defaults to 1.0.
+     */
+    rate?: number
+    /**
+     * Fade in from silence over this many milliseconds (sample-accurate).
+     * Defaults to 0 (start at full level).
+     */
+    fadeInMs?: number
+    /**
+     * Name of the bus this playback belongs to, so `stop({ bus })` can stop
+     * the whole group at once. Buses are plain names created by use - no
+     * setup call, and (for now) no per-bus gain.
+     */
+    bus?: string
+  }
+
+  /** Options for the live setters ({@link Playback.setGain} and friends). */
+  type RampOptions = {
+    /**
+     * Reach the new value by ramping over this many milliseconds instead of
+     * jumping. Linear, stepped by the engine at control rate (about every
+     * 10 ms), so a fade stays smooth regardless of the app's frame rate. A
+     * later set on the same parameter takes over from the ramp's current
+     * value; omitted (or 0) sets immediately and cancels any ramp in flight.
+     */
+    rampMs?: number
+  }
+
+  /** Options for {@link Playback.stop} and the module-level {@link stop}. */
+  type StopOptions = {
+    /**
+     * Fade to silence over this many milliseconds before stopping
+     * (sample-accurate) instead of cutting immediately. The playback keeps
+     * playing while it fades; ended() turns true once the fade completes.
+     */
+    fadeOutMs?: number
+  }
+
+  /** Options for the module-level {@link stop}. */
+  type StopAllOptions = StopOptions & {
+    /**
+     * Stop only the playbacks on this bus (see {@link PlayOptions.bus})
+     * instead of everything.
+     */
+    bus?: string
   }
 
   /** One playing instance of a clip, with live controls bound to it. */
   type Playback = {
-    /** Stop this playback. A no-op if it already finished. */
-    stop(): void
+    /**
+     * Stop this playback. A no-op if it already finished. Stopping is not
+     * pausing: a stopped playback is gone for good, including a looping one -
+     * to silence it temporarily, ramp its gain to 0 instead.
+     */
+    stop(options?: StopOptions): void
     /**
      * Change the volume while playing. A finite number >= 0; 1.0 is the clip's
      * own level. A no-op after the playback finished.
      */
-    setGain(gain: number): void
+    setGain(gain: number, options?: RampOptions): void
     /**
      * Move the stereo position while playing (see {@link PlayOptions.pan}).
+     * A ramped set on a never-panned playback sweeps from center. A no-op
+     * after the playback finished.
+     */
+    setPan(pan: number, options?: RampOptions): void
+    /**
+     * Change the playback rate while playing (see {@link PlayOptions.rate}) -
+     * a live rate sweep is how an engine revs or a doppler pass falls.
      * A no-op after the playback finished.
      */
-    setPan(pan: number): void
+    setRate(rate: number, options?: RampOptions): void
     /** Whether playback finished, naturally or via {@link stop}. */
     ended(): boolean
   }
 
   /** A loaded clip that can be played without re-decoding. */
   type Clip = {
-    /** Start a fresh overlapping playback of this clip. */
+    /**
+     * Start a fresh overlapping playback of this clip. Throws once 256
+     * playbacks are live at once - a guard that turns a runaway play() loop
+     * into an error instead of a saturated mixer.
+     */
     play(options?: PlayOptions): Playback
-    /** Release the clip. Playbacks already running keep going. */
+    /**
+     * Release the clip. Playbacks already running keep going; `play()` after
+     * unloading throws.
+     */
     unload(): void
   }
 
@@ -80,6 +149,41 @@ declare module "flux:audio" {
    * playback; do not overlap a stream with itself. Call `unload()` when done.
    */
   export function stream(source: ReturnType<typeof import("flux:fs").file>): Clip
-  /** Stop every playing sound. */
-  export function stop(): void
+  /**
+   * Stop every playing sound - or just one bus with `{ bus }` - fading it
+   * out first if asked. Stopping is not pausing: stopped playbacks (looping
+   * ones included) cannot be restarted - to silence a group temporarily,
+   * ramp gains to 0 instead.
+   */
+  export function stop(options?: StopAllOptions): void
+  /**
+   * Scale the whole mix: every playing and future flux:audio playback, on top
+   * of per-playback gains (1.0 = unchanged, 0 = silence). A finite number
+   * >= 0; ramps like the per-playback setters. Resets to 1.0 when the app
+   * reloads.
+   */
+  export function setMasterGain(gain: number, options?: RampOptions): void
+  /**
+   * Scale one bus (see {@link PlayOptions.bus}): a playback's audible level
+   * is its own gain x its bus's gain x the master gain, each layer set
+   * independently - none overwrites another. Applies to live and future
+   * playbacks on the bus, defaults to 1.0, resets to 1.0 when the app
+   * reloads, and ramps like the other gain setters.
+   *
+   * NOT IMPLEMENTED YET: calling this throws. Until it lands, keep the bus
+   * gain in the app and fold it into each voice's setGain - one ramped
+   * write per change:
+   *
+   * ```ts
+   * let musicGain = 0.3
+   * for (let v of musicVoices) v.setGain(voiceGain * musicGain, { rampMs: 200 })
+   * ```
+   */
+  export function setBusGain(bus: string, gain: number, options?: RampOptions): void
+  /**
+   * The mixer's output sample rate in Hz. Synthesize PCM at this rate and
+   * {@link loadPcm} feeds it to the mixer without a resample. Opens the audio
+   * device on first use, like the load and play calls.
+   */
+  export function outputSampleRate(): number
 }

package/gui/gpu.d.ts

@@ -310,7 +310,11 @@ declare module "flux:gpu" {
        * arithmetic. Declaring any makes `instanceBuffer` required on every
        * entry drawn with this pipeline. A mat4 per instance is its four
        * vec4 columns, reassembled in the shader (attributes have no matrix
-       * formats, as in WebGPU).
+       * formats, as in WebGPU). Instance N always reads record N of the
+       * entry's buffer, from record 0 (ES 3.0 has no base instance), so
+       * several independently culled groups cannot share one buffer as
+       * sub-ranges: give each group its own `instanceBuffer` and entry, and
+       * cull it by `instanceCount`.
        */
       instanceAttributes?: VertexAttribute[]
       topology?: Topology
@@ -453,7 +457,9 @@ declare module "flux:gpu" {
    * buffer bound, `instanceCount` is bounds-checked against it like every
    * fetch (instances 0..N-1 each read one record). Two GL facts worth
    * knowing: `gl_VertexID` includes `firstVertex` (as in WebGPU), and
-   * `gl_InstanceID` always counts from 0 - ES 3.0 has no base instance.
+   * `gl_InstanceID` always counts from 0 - ES 3.0 has no base instance, so
+   * instance N reads record N of the entry's `instanceBuffer` and a group
+   * that is culled independently needs its own buffer and entry.
    */
   export type DrawRange = { firstVertex?: number; vertexCount?: number; instanceCount?: number }
   /**
@@ -546,10 +552,34 @@ declare module "flux:gpu" {
 
   /**
    * Create a vertex buffer from raw bytes (interleave attribute data to match
-   * the pipeline's attribute list). Buffer ids are their own space, separate
-   * from texture ids.
+   * the pipeline's attribute list), or from a byte length alone - a zeroed
+   * buffer, the natural create when the contents arrive through the write
+   * lease ({@link beginBufferWrite}). Buffer ids are their own space,
+   * separate from texture ids. Size is fixed for the id's lifetime: reserve
+   * the maximum up front and publish a prefix.
+   */
+  export function createBuffer(data: Uint8Array | number, opts?: LabelOption): BufferId
+  /**
+   * Open a zero-copy write into a vertex buffer: returns an ArrayBuffer over
+   * runtime-owned memory exactly the buffer's size. Write into it in place
+   * (wrap it in a Float32Array or any view), then publish with
+   * {@link endBufferWrite} - no copy happens anywhere on the CPU path.
+   *
+   * Contents are UNSPECIFIED at begin: a recycled block holds what was
+   * published the time before last, so fill everything you publish. One open
+   * write per buffer id at a time (a second begin throws). The view is
+   * detached at end/destroy - a retained reference becomes zero-length, and
+   * writes through it are inert, never a race.
+   */
+  export function beginBufferWrite(id: BufferId): ArrayBuffer
+  /**
+   * Publish the open write's first `byteLength` bytes at offset 0 (default:
+   * the whole buffer) and close the lease. `byteLength` 0 cancels: the lease
+   * closes and nothing is published. Always closes the lease, error or not;
+   * throws when no write is open or `byteLength` exceeds the buffer size.
+   * Pipelines drawing from the buffer re-render, like {@link writeBuffer}.
    */
-  export function createBuffer(data: Uint8Array, opts?: LabelOption): BufferId
+  export function endBufferWrite(id: BufferId, byteLength?: number): void
   /**
    * Overwrite part of a vertex buffer at `byteOffset` (default 0), within the
    * size it was created with. Pipelines drawing from the buffer re-render

package/gui/rendertree.d.ts

@@ -14,6 +14,27 @@ declare module "flux:rendertree" {
     lineHeight?: number
     /** measureText only. */
     maxLines?: number
+    /** prepareText only: also report each unit's {@link TextUnit.carets}. */
+    carets?: boolean
+    /**
+     * prepareText only: styled ranges over the text, in JS string offsets,
+     * sorted and disjoint (text between them is in the base font). Each
+     * overrides the font options it names. A wrap unit crossing a range
+     * boundary comes back as one {@link TextUnit} per range, the pieces
+     * after the first `glue`d to it. Throws on an invalid range.
+     */
+    runs?: TextRunRange[]
+  }
+
+  /** One styled range for {@link MeasureTextOptions.runs}. */
+  export interface TextRunRange {
+    start: number
+    end: number
+    fontFamily?: "sans" | "serif" | "mono" | (string & {})
+    fontSize?: number
+    fontStyle?: "normal" | "italic"
+    fontWeight?: 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900
+    lineHeight?: number
   }
 
   /**
@@ -35,6 +56,17 @@ declare module "flux:rendertree" {
     descent: number
     /** The unit ends at a hard line break (newline). */
     hardBreak: boolean
+    /** A continuation piece of the previous unit (it crossed a `runs` boundary): a line never breaks before it. */
+    glue: boolean
+    /** Index into `runs` of the range this piece was shaped in; absent for the base font. */
+    run?: number
+    /**
+     * With `carets`: the caret positions inside the unit, one per grapheme
+     * cluster boundary from its start (`offset` = start, x 0) to the end of
+     * its shaped text (before any break characters), in order. `offset` is
+     * into the prepared text, `x` from the unit's pen position.
+     */
+    carets?: { offset: number, x: number }[]
   }
 
   /** The wrap units of a text in one font, shaped once. Plain data; layout is arithmetic over `units`. */
@@ -45,24 +77,34 @@ declare module "flux:rendertree" {
 
   /** Create the window root node with the given id. */
   export function createRoot(id: number): void
-  /** Create a node of `kind` (the primitive element name) with the given id. */
+  /** 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). */
   export function insertNode(parentId: number, nodeId: number, anchorId?: number): void
   /**
    * Unlink `nodeId` from `parentId` but keep its subtree alive, so it can be
    * re-inserted elsewhere (a move). Mirrors DOM removeChild. Pair with
-   * {@link destroyNode} once the node is confirmed dead.
+   * {@link destroyNode} once the node is confirmed dead. Divergence: a node
+   * whose `transition` declares `exit` values stays linked and animates them
+   * first; the unlink happens when the exit settles, and a re-insert before
+   * then abandons it (moves never play removal animations).
    */
   export function detachNode(parentId: number, nodeId: number): void
-  /** Free `nodeId` and its whole subtree. Call after {@link detachNode}. */
+  /**
+   * Free `nodeId` and its whole subtree. Call after {@link detachNode}. A
+   * node mid-exit is freed when its exit animation settles instead.
+   */
   export function destroyNode(nodeId: number): void
   /**
    * Write a single property on a node; `value` is marshalled per property.
-   * Throws an `Error` for an unknown property name (message starts with
-   * "Unknown property") or a value that does not decode; it never aborts the
-   * runtime. Core's renderer warns-and-continues on the name-level rejections
-   * and rethrows value errors.
+   * `null`/`undefined` resets the property to its default (its value before
+   * anything was set, per element kind; on a span, back to inheriting from
+   * the paragraph). Content props (`text`, `d`) still require a value.
+   * Throws an `Error` for an unknown
+   * property name (message starts with "Unknown property") or a value that
+   * does not decode; it never aborts the runtime. Core's renderer
+   * warns-and-continues on the name-level rejections and rethrows value
+   * errors.
    */
   export function setProperty(nodeId: number, name: string, value: unknown): void
   /**
@@ -87,6 +129,13 @@ declare module "flux:rendertree" {
   }
   /** Enable or disable text-input capture / the on-screen keyboard. */
   export function setTextInputActive(active: boolean, hints?: TextInputHints): void
+  /**
+   * Enter or leave relative mouse mode (pointer lock): the cursor hides and
+   * confines to the window, absolute pointer positions freeze, and mouse
+   * motion keeps reporting through movementX/movementY. The applied state
+   * comes back on the sticky "pointerLock" bus event.
+   */
+  export function setPointerLock(locked: boolean): void
   /** Request that a frame be rendered soon (coalesced by the demand-driven loop). */
   export function requestFrame(): void
   /**
@@ -121,4 +170,18 @@ declare module "flux:rendertree" {
    * semantics), for comparing against pointer event coordinates.
    */
   export function getBoundingBoxViewport(id: number): { x: number, y: number, width: number, height: number } | null
+  /**
+   * Parses a CSS color string (hex, rgb()/rgba(), hsl()/hsla(), hwb(),
+   * named colors) into packed 0xRRGGBBAA form (which the color property
+   * also accepts alongside plain CSS strings). Throws on an invalid string.
+   */
+  export function parseColor(color: string): number
+  /**
+   * Mixes two CSS colors in oklab; `t` is the fraction of `b` (0 = pure
+   * `a`, 1 = pure `b`). Returns a hex string, with an alpha byte only when
+   * the mix is translucent.
+   */
+  export function mixColors(a: string, b: string, t: number): string
+  /** Perceived brightness of a CSS color, 0 (black) to 1 (white), YIQ-weighted. */
+  export function brightness(color: string): number
 }

package/index.d.ts

@@ -22,6 +22,7 @@
 /// <reference path="./standards/base64.d.ts" />
 /// <reference path="./standards/fetch.d.ts" />
 /// <reference path="./standards/websocket.d.ts" />
+/// <reference path="./standards/abort.d.ts" />
 
 // GUI capabilities (present only on a gui-enabled runtime). rendertree/camera/
 // microphone/gpu are flux:* modules like the rest; requestAnimationFrame stays a

package/modules/isolate.d.ts

@@ -22,6 +22,14 @@ declare module "flux:isolate" {
   type IsolateOptions = {
     /** The child's `flux:process` `argv`. Default `[]`. */
     args?: string[]
+    /**
+     * Heap limit in bytes for the child runtime. Once reached, allocations in
+     * the child fail with an out-of-memory error where they happen instead of
+     * growing the process; an exit this causes is observable via `exited`.
+     * Applies to this child only (not to isolates it spawns itself). Default:
+     * unlimited.
+     */
+    memoryLimit?: number
   }
 
   /**
@@ -36,8 +44,10 @@ declare module "flux:isolate" {
       ? 0 extends 1 & R // an `any` result (untyped module) is a plain call, not a stream
         ? (...args: A) => Promise<any>
         : R extends AsyncIterable<infer Y>
-          ? (...args: A) => AsyncIterableIterator<Y>
-          : (...args: A) => Promise<Awaited<R>>
+          ? (...args: A | [...A, AbortSignal]) => AsyncIterableIterator<Y>
+          : R extends Generator<any, any, any> // sync generators do not stream: the call rejects
+            ? never
+            : (...args: A | [...A, AbortSignal]) => Promise<Awaited<R>>
       : never
   } & {
     /**
@@ -46,28 +56,58 @@ declare module "flux:isolate" {
      * anything never spawned.
      */
     terminate(): void
+    /**
+     * Settles once the child is gone: with the uncaught error that ended it,
+     * or `null` after `terminate()` or a clean end. Reading `exited` is a
+     * first use (it starts the child like a call does) and keeps the runtime
+     * watching the child - the loop stays open until the child exits, so an
+     * exit is noticed with no call in flight. Each read returns an
+     * equivalent promise.
+     */
+    readonly exited: Promise<string | null>
   }
 
   /**
    * A handle on an isolate module: a `"use isolate"` module in a SolidRT
    * project (id = its path relative to the source root, without extension),
-   * or `<id>.js` next to the entry under standalone flux. Each property is
+   * or `isolates/<id>.bin`/`.js` next to the entry under standalone flux. Each property is
    * an async function that runs the export of that name in a second runtime
    * on its own thread (own heap, own event loop, the non-gui `flux:*`
    * modules). Arguments and results are copied ({@link Sendable}).
    *
-   * The child starts on the first call and lives until `terminate()` or the
-   * parent's end; module state persists between calls; each `isolate()` call
-   * is its own instance. Calls start in call order and run concurrently, as
+   * The child starts on first use (a call, or reading `exited`) and lives
+   * until `terminate()` or the parent's end; module state persists between
+   * calls; each `isolate()` call is its own instance. Calls start in call order and run concurrently, as
    * the same functions would in-process: a sync export runs to completion
    * before anything else (one thread), an async export lets other calls and
    * stream steps run at each `await`; an export that must not interleave with
    * itself serialises inside the module. A throw in the export rejects that
-   * call (a throw in a generator rejects the pending step); an uncaught error
-   * that ends the child rejects pending and later calls with a message naming
-   * it. Awaiting a stream call rejects; iterating a plain call rejects. An
+   * call (a throw in a generator rejects the pending step) with the error
+   * rebuilt from its data: `name`, `message` and `stack` carry over, `e
+   * instanceof RangeError` holds for the standard error types (a custom error
+   * class arrives as an `Error` with its `name`), and the `cause` chain
+   * carries over - each cause another rebuilt error or a {@link Sendable}
+   * value (an unsendable cause is dropped; the chain is capped). A thrown
+   * non-Error rejects with the thrown value itself when it is sendable, else
+   * with an `Error` describing it. An uncaught
+   * error that ends the child rejects pending and later calls with a message
+   * naming it. Awaiting a stream call rejects; iterating a plain call rejects. An
    * open stream keeps both runtimes alive until it ends, `break`s, or the
-   * child is terminated. Reserved names: `terminate`, `then`.
+   * child is terminated. A sync generator export rejects when called: only
+   * async generators stream.
+   *
+   * An `AbortSignal` among a call's arguments (anywhere in the list; at most
+   * one, more throw) is consumed as the call's signal rather than sent: the
+   * export sees only the other arguments. On a plain call, aborting stops
+   * the waiting - the call rejects with `signal.reason` and the eventual
+   * result is dropped - but does not interrupt the export; interrupting is
+   * `terminate()`'s job. On a stream, aborting acts as `return()`: the
+   * generator ends in the isolate (its `finally` runs) and the `for await`
+   * loop finishes cleanly, like a `break` from outside it. A call on an
+   * already-aborted signal rejects without sending anything (or starting the
+   * child).
+   *
+   * Reserved names: `terminate`, `exited`, `then`.
    */
   export function isolate<T = Record<string, (...args: any[]) => any>>(id: string, opts?: IsolateOptions): Isolated<T>
 }

package/modules/sqlite.d.ts

@@ -1,12 +1,12 @@
 declare module "flux:sqlite" {
   /** Values accepted as bound parameters. booleans bind as 0/1. */
-  type SqlParam = null | boolean | number | string | Uint8Array
+  export type SqlParam = null | boolean | number | string | Uint8Array
   /** Values returned in result rows. BLOB comes back as Uint8Array. */
-  type SqlValue = null | number | string | Uint8Array
-  type Row = Record<string, SqlValue>
+  export type SqlValue = null | number | string | Uint8Array
+  export type Row = Record<string, SqlValue>
 
   /** The outcome of a write. */
-  type RunResult = { changes: number; lastInsertRowid: number }
+  export type RunResult = { changes: number; lastInsertRowid: number }
 
   /**
    * A reusable prepared statement. Created with {@link Database.query}; its
@@ -19,13 +19,20 @@ declare module "flux:sqlite" {
     get(params?: SqlParam[]): Promise<Row | undefined>
     /** Run the statement as a write and resolve to its {@link RunResult}. */
     run(params?: SqlParam[]): Promise<RunResult>
+    /**
+     * The tables this statement reads, sorted (SQLite's authorizer, captured
+     * during a compile; the statement is never run). Includes tables reached
+     * through views and subqueries. Pair with {@link Database.onWrite} to know
+     * when a re-read could return different rows.
+     */
+    tables(): Promise<string[]>
   }
 
   /**
    * Open mode: "ro" (default, read-only, must exist), "rw" (read-write, must
    * exist), "rw+" (read-write, create if missing).
    */
-  type OpenMode = "ro" | "rw" | "rw+"
+  export type OpenMode = "ro" | "rw" | "rw+"
 
   export class Database {
     /**
@@ -47,6 +54,21 @@ declare module "flux:sqlite" {
      * must be writes/DDL. Cannot branch on intermediate results.
      */
     transaction(statements: [string, SqlParam[]?][]): Promise<RunResult[]>
+    /**
+     * Subscribe to writes on this connection. After each command that changed
+     * rows, `callback` gets one call with the sorted names of the tables
+     * touched (SQLite's update hook, so trigger and cascade writes are
+     * included). Returns an unsubscribe function.
+     *
+     * Contract: only THIS connection's writes are seen (another connection or
+     * process writing the same file does not report); SQLite does not fire
+     * the hook for WITHOUT ROWID tables; a rolled-back transaction may still
+     * report its tables (a spurious re-read, never a stale one). A full-table
+     * `DELETE FROM t` reports correctly: the connection disables SQLite's
+     * truncate optimization, trading row-by-row deletion for a hook that
+     * cannot be silently skipped.
+     */
+    onWrite(callback: (tables: string[]) => void): () => void
     /** Close the connection. */
     close(): Promise<void>
   }

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@solidrt/flux-types",
-  "version": "0.0.50",
+  "version": "0.0.51",
   "license": "MIT",
+  "funding": "https://github.com/sponsors/wellawaretech",
   "author": "Antoine van Wel",
   "types": "index.d.ts",
   "files": [

package/standards/abort.d.ts

@@ -0,0 +1,36 @@
+// The web-standard abort primitives. A deliberate subset: an `onabort`
+// handler property only (no addEventListener), a plain-object event (not an
+// Event instance), and no `AbortSignal.timeout`/`any`. Without `DOMException`
+// the default abort reason is an `Error` whose `name` is "AbortError".
+
+/** The event passed to {@link AbortSignal.onabort}. */
+interface AbortEvent {
+  type: "abort"
+}
+
+interface AbortSignal {
+  /** True once the signal has been aborted. */
+  readonly aborted: boolean
+  /** The abort reason; `undefined` until aborted. */
+  readonly reason: any
+  /** Called once when the signal aborts. */
+  onabort: ((event: AbortEvent) => void) | null
+  /** Throws `reason` if the signal is aborted; no-op otherwise. */
+  throwIfAborted(): void
+}
+
+declare let AbortSignal: {
+  prototype: AbortSignal
+  /** An already-aborted signal. */
+  abort(reason?: any): AbortSignal
+}
+
+declare class AbortController {
+  /** The controller's signal; the same object on every read. */
+  readonly signal: AbortSignal
+  /**
+   * Abort the signal with `reason` (default: an `Error` named "AbortError")
+   * and fire its `onabort`. Aborting an already-aborted signal is a no-op.
+   */
+  abort(reason?: any): void
+}

package/standards/fetch.d.ts

@@ -1,6 +1,6 @@
 // The Fetch API cluster (Headers, Request, Response, fetch). A deliberate subset
 // of the WHATWG Fetch standard: flux provides exactly these members and no more
-// (no Blob, FormData, ReadableStream, clone(), AbortSignal, ...).
+// (no Blob, FormData, ReadableStream, clone(), ...).
 // Grouped in one file because the four share BodyInit/HeadersInit and reference
 // each other.
 
@@ -70,6 +70,13 @@ interface RequestInit {
    * throttled.
    */
   cache?: "force-cache" | "reload" | "default" | "no-store" | "no-cache"
+  /**
+   * Abort signal for `fetch`: aborting rejects the fetch promise with the
+   * signal's `reason` and drops the request mid-flight; a fetch on an
+   * already-aborted signal rejects without sending anything. Ignored by the
+   * `Request` constructor.
+   */
+  signal?: AbortSignal
 }
 
 /**

package/standards/time.d.ts

@@ -2,14 +2,20 @@
 // from the browser in two ways: the delay is required, and no extra callback
 // arguments are forwarded.
 //
-// In a GUI runtime the whole time surface here is FRAME-STEPPED: timers and
-// performance.now() march on the same paced timeline as onFrame and
-// requestAnimationFrame, quantized to frames. So timer resolution is one
-// frame (~16 ms at 60 Hz; a setTimeout of 0 runs on the next frame), an
-// interval fires at most once per frame, and pausing the runtime clock (the
-// dev tools' set_time_scale 0) freezes all of it together deterministically.
-// Date.now() is the wall-clock escape hatch: it always reports real calendar
-// time. Headless flux (scripts, servers) keeps ordinary wall-clock timers.
+// In a GUI runtime the timers are FRAME-QUANTIZED but WALL-ACCURATE: a
+// deadline is measured against the real clock from the moment of
+// registration, and firing happens on frame boundaries. So a timer fires at
+// the first frame at or after its deadline - at least `ms` after
+// registration, at most one frame late (~16 ms at 60 Hz; a setTimeout of 0
+// runs on the next frame) - and deadlines do not drift when frames run
+// slow. An interval fires at most once per frame (missed periods collapse
+// instead of storming). Pausing the runtime clock (the dev tools'
+// set_time_scale 0) freezes timers and frame callbacks together; a timer
+// that came due while the app was suspended (backgrounded) fires on the
+// resume frame. performance.now() is real elapsed time, for measuring
+// work; the onFrame / requestAnimationFrame timestamp is a separate paced
+// animation timeline. Date.now() is calendar time. Headless flux (scripts,
+// servers) keeps ordinary wall-clock timers.
 
 /**
  * Run `callback` after at least `ms` milliseconds. Returns a timer id for
@@ -33,17 +39,16 @@ declare function queueMicrotask(callback: () => void): void
 
 declare let performance: {
   /**
-   * Milliseconds since a monotonic origin (high-resolution, not wall-clock). Use
-   * for measuring durations, not for calendar time. In a GUI runtime this is
-   * the paced frame timeline (same clock as the onFrame/requestAnimationFrame
-   * timestamps, frozen while the runtime clock is paused); for real elapsed
-   * wall time use Date.now().
+   * Milliseconds elapsed since the runtime started (high-resolution,
+   * monotonic, sub-millisecond). Real time: it keeps advancing across
+   * synchronous work and while the runtime clock is paused, so it is the
+   * clock for measuring durations. For frame time use the onFrame /
+   * requestAnimationFrame timestamp; for calendar time use Date.now().
    */
   now(): number
   /**
-   * Wall-clock time (ms since the Unix epoch) when the runtime started. Unlike
-   * the browser, timeOrigin + now() is not the current wall-clock time: now()
-   * runs on the paced runtime timeline, which can be frozen or scaled.
+   * Wall-clock time (ms since the Unix epoch) when the runtime started, so
+   * timeOrigin + now() tracks Date.now().
    */
   readonly timeOrigin: number
 }