@mikrojs/native 0.20.1 → 0.21.0-next.20260913195055

package/runtime/observable/operators.ts

@@ -1,6 +1,7 @@
-/* Operators for `Observable.pipe(...)`. Each is a factory returning a
- * function `(source) => Observable`. Composition is pure pipe — no method
- * chaining on Observable itself.
+/* Operators for `Observable.pipe(...)`, declared here and implemented in C
+ * (mik_observable.cpp, module `mikro/observable/operators`). Each is a
+ * factory returning a function `(source) => Observable`. Composition is pure
+ * pipe: no method chaining on Observable itself.
  *
  * M0 scope: operators apply to non-fallible streams (`Err = never`). For
  * fallible streams (`Observable<Ok, Err>` with Err != never), corresponding
@@ -14,97 +15,163 @@
  * See `.claude/plans/observable.md` for the full design.
  */
 
-import {Observable as NativeObservable} from 'native:mikro/observable'
+import type {Observable} from './types.js'
 
-import type {Observable as ObservableT} from './types.js'
-
-/* `native:mikro/observable` resolves only inside the runtime build; outside
- * (twoslash, host typecheck without internal.d.ts) it falls back to `any`,
- * which collapses pipe/operator inference at use sites. Pin the type to the
- * declared class in `./types.ts` so consumers always see the typed shape. */
-const Observable = NativeObservable as unknown as typeof ObservableT
-type Observable<Ok, Err = never> = ObservableT<Ok, Err>
+type Op<A, B> = (source: Observable<A>) => Observable<B>
 
 /* Map values through a transform. A throw inside `fn` panics. */
-export const map =
-  <A, B>(fn: (value: A) => B) =>
-  (source: Observable<A>): Observable<B> =>
-    new Observable<B>((sub) => {
-      const upstream = source.subscribe({
-        next: (value) => sub.next(fn(value)),
-        complete: () => sub.complete(),
-      })
-      sub.addTeardown(() => upstream.unsubscribe())
-    })
-
-/* Pass through values matching `predicate`. A throw inside it panics. */
-export const filter =
-  <A>(predicate: (value: A) => boolean) =>
-  (source: Observable<A>): Observable<A> =>
-    new Observable<A>((sub) => {
-      const upstream = source.subscribe({
-        next: (value) => {
-          if (predicate(value)) sub.next(value)
-        },
-        complete: () => sub.complete(),
-      })
-      sub.addTeardown(() => upstream.unsubscribe())
-    })
+export declare function map<A, B>(fn: (value: A) => B): Op<A, B>
+
+/* Pass through values matching `predicate`; a type guard narrows the output.
+ * A throw inside it panics. */
+export declare function filter<A, B extends A>(predicate: (value: A) => value is B): Op<A, B>
+export declare function filter<A>(predicate: (value: A) => boolean): Op<A, A>
+
+/* Run `fn` on each value, then pass it through unchanged. A throw inside
+ * `fn` panics. */
+export declare function tap<A>(fn: (value: A) => void): Op<A, A>
 
 /* Take at most `count` values, then complete. count <= 0 completes immediately. */
-export const take =
-  (count: number) =>
-  <A>(source: Observable<A>): Observable<A> =>
-    new Observable<A>((sub) => {
-      if (count <= 0) {
-        sub.complete()
-        return
-      }
-      let remaining = count
-      const upstream = source.subscribe({
-        next: (value) => {
-          if (remaining <= 0) return
-          remaining--
-          sub.next(value)
-          if (remaining === 0) sub.complete()
-        },
-        complete: () => sub.complete(),
-      })
-      sub.addTeardown(() => upstream.unsubscribe())
-    })
-
-/* Stop emitting when `notifier` emits its first value. Notifier completing
- * without emitting is NOT a trigger — primary keeps going. */
-export const takeUntil =
-  (notifier: Observable<unknown, unknown>) =>
-  <A>(source: Observable<A>): Observable<A> =>
-    new Observable<A>((sub) => {
-      const upstream = source.subscribe({
-        next: (value) => sub.next(value),
-        complete: () => sub.complete(),
-      })
-      const notifierSub = notifier.subscribe({
-        next: () => sub.complete(),
-      })
-      sub.addTeardown(() => {
-        notifierSub.unsubscribe()
-        upstream.unsubscribe()
-      })
-    })
+export declare function take(count: number): <A>(source: Observable<A>) => Observable<A>
+
+/* Drop the first `count` values, then pass the rest through. */
+export declare function skip(count: number): <A>(source: Observable<A>) => Observable<A>
+
+/* Fold values into an accumulator, emitting each intermediate result. */
+export declare function scan<A, B>(fn: (acc: B, value: A) => B, seed: B): Op<A, B>
+
+/* Drop values equal (by ===, or `equals`) to the previous one. */
+export declare function distinctUntilChanged<A>(equals?: (a: A, b: A) => boolean): Op<A, A>
+
+/* Emit `value` on subscribe, then pass the source through. */
+export declare function startWith<A>(value: A): Op<A, A>
 
 /* Run `fn` when the subscription ends for any reason (unsubscribe or
  * natural completion). A throw inside `fn` panics; the remaining teardowns
- * still run. RxJS naming. */
-export const finalize =
-  (fn: () => void) =>
-  <A>(source: Observable<A>): Observable<A> =>
-    new Observable<A>((sub) => {
-      const upstream = source.subscribe({
-        next: (value) => sub.next(value),
-        complete: () => sub.complete(),
-      })
-      sub.addTeardown(() => {
-        upstream.unsubscribe()
-        fn()
-      })
-    })
+ * still run. */
+export declare function finalize(fn: () => void): <A>(source: Observable<A>) => Observable<A>
+
+/* Stop when `until` fires. An Observable ends the stream when it emits a
+ * value (completing alone does not); a predicate ends it at the first value
+ * it accepts, delivered too unless `inclusive` is false. */
+export declare function takeUntil(
+  notifier: Observable<unknown, unknown>,
+): <A>(source: Observable<A>) => Observable<A>
+export declare function takeUntil<A>(
+  predicate: (value: A) => boolean,
+  options?: {inclusive?: boolean},
+): Op<A, A>
+
+/* Interleave the source with `others`; completes when all of them have. */
+export declare function mergeWith<A, B>(...others: Array<Observable<B>>): Op<A, A | B>
+
+/* Pair each source value with the latest value of `other`. Source values
+ * arriving before `other` has emitted are dropped. */
+export declare function withLatestFrom<A, B>(other: Observable<B>): Op<A, [A, B]>
+
+/* Emit the latest values of all sources whenever any of them emits, once
+ * every source has emitted. Completes when all sources have, or as soon as
+ * one completes without a value (no tuple can ever form). */
+export declare function combineLatest<T extends readonly unknown[]>(sources: {
+  [K in keyof T]: Observable<T[K]>
+}): Observable<T>
+
+/* Compose operators left to right into one operator, for reuse across
+ * streams or as a `state()` pipeline. */
+export declare function pipe<A>(): Op<A, A>
+export declare function pipe<A, B>(op1: Op<A, B>): Op<A, B>
+export declare function pipe<A, B, C>(op1: Op<A, B>, op2: Op<B, C>): Op<A, C>
+export declare function pipe<A, B, C, D>(op1: Op<A, B>, op2: Op<B, C>, op3: Op<C, D>): Op<A, D>
+export declare function pipe<A, B, C, D, E>(
+  op1: Op<A, B>,
+  op2: Op<B, C>,
+  op3: Op<C, D>,
+  op4: Op<D, E>,
+): Op<A, E>
+export declare function pipe<A, B, C, D, E, F>(
+  op1: Op<A, B>,
+  op2: Op<B, C>,
+  op3: Op<C, D>,
+  op4: Op<D, E>,
+  op5: Op<E, F>,
+): Op<A, F>
+export declare function pipe<A, B, C, D, E, F, G>(
+  op1: Op<A, B>,
+  op2: Op<B, C>,
+  op3: Op<C, D>,
+  op4: Op<D, E>,
+  op5: Op<E, F>,
+  op6: Op<F, G>,
+): Op<A, G>
+export declare function pipe<A, B, C, D, E, F, G, H>(
+  op1: Op<A, B>,
+  op2: Op<B, C>,
+  op3: Op<C, D>,
+  op4: Op<D, E>,
+  op5: Op<E, F>,
+  op6: Op<F, G>,
+  op7: Op<G, H>,
+): Op<A, H>
+export declare function pipe<A, B, C, D, E, F, G, H, I>(
+  op1: Op<A, B>,
+  op2: Op<B, C>,
+  op3: Op<C, D>,
+  op4: Op<D, E>,
+  op5: Op<E, F>,
+  op6: Op<F, G>,
+  op7: Op<G, H>,
+  op8: Op<H, I>,
+): Op<A, I>
+export declare function pipe<A, B, C, D, E, F, G, H, I, J>(
+  op1: Op<A, B>,
+  op2: Op<B, C>,
+  op3: Op<C, D>,
+  op4: Op<D, E>,
+  op5: Op<E, F>,
+  op6: Op<F, G>,
+  op7: Op<G, H>,
+  op8: Op<H, I>,
+  op9: Op<I, J>,
+): Op<A, J>
+/* Longer chains still compose; type them by hand from the result. */
+export declare function pipe<A, B, C, D, E, F, G, H, I, J>(
+  op1: Op<A, B>,
+  op2: Op<B, C>,
+  op3: Op<C, D>,
+  op4: Op<D, E>,
+  op5: Op<E, F>,
+  op6: Op<F, G>,
+  op7: Op<G, H>,
+  op8: Op<H, I>,
+  op9: Op<I, J>,
+  ...ops: Array<Op<any, any>>
+): Op<A, unknown>
+
+/* Map each value to an inner stream and pass on the latest inner stream's
+ * values; a new value unsubscribes the previous inner stream. Completes once
+ * the source and the last inner stream have both completed. */
+export declare function switchMap<A, B>(project: (value: A) => Observable<B>): Op<A, B>
+
+/* Emit 0 after `delayMs`, then complete; with `periodMs`, keep counting up
+ * every period instead. */
+export declare function timer(delayMs: number, periodMs?: number): Observable<number>
+
+/* Which edge of a burst an operator emits on. */
+export type EdgeOptions = {leading?: boolean; trailing?: boolean}
+
+/* Emit a value only once `ms` have passed without another one. `trailing`
+ * (default) emits the last value of a burst when it ends; `leading` emits the
+ * first one at once. A pending trailing value is flushed on complete. */
+export declare function debounceTime(
+  ms: number,
+  options?: EdgeOptions,
+): <A>(source: Observable<A>) => Observable<A>
+
+/* Emit one value per `ms` window and drop the rest. `leading` (default)
+ * emits the value that opens a window; `trailing` emits the last dropped one
+ * when the window ends, which opens the next window. A pending trailing
+ * value is flushed on complete. */
+export declare function throttleTime(
+  ms: number,
+  options?: EdgeOptions,
+): <A>(source: Observable<A>) => Observable<A>

package/runtime/observable/types.ts

@@ -20,7 +20,8 @@ export interface Subscriber<Ok, Err = never> {
   readonly closed: boolean
 }
 
-export type SubscribeCallback<Ok, Err> = (subscriber: Subscriber<Ok, Err>) => void
+/* May return a teardown function, registered as if passed to addTeardown() last. */
+export type SubscribeCallback<Ok, Err> = (subscriber: Subscriber<Ok, Err>) => void | (() => void)
 
 export interface Subscription {
   unsubscribe(): void
@@ -66,11 +67,49 @@ export declare class Observable<Ok, Err = never> {
     op5: OperatorFunction<D, Err, E, Err>,
     op6: OperatorFunction<E, Err, F, Err>,
   ): Observable<F, Err>
-
-  static from<X, E>(p: Promise<Result<X, E>>): Observable<X, E>
-  static from<T>(p: Promise<T>): Observable<T, never>
-  static from<T>(it: Iterable<T>): Observable<T, never>
-  static from<Ok, Err>(o: Observable<Ok, Err>): Observable<Ok, Err>
+  pipe<A, B, C, D, E, F, G>(
+    op1: OperatorFunction<Ok, Err, A, Err>,
+    op2: OperatorFunction<A, Err, B, Err>,
+    op3: OperatorFunction<B, Err, C, Err>,
+    op4: OperatorFunction<C, Err, D, Err>,
+    op5: OperatorFunction<D, Err, E, Err>,
+    op6: OperatorFunction<E, Err, F, Err>,
+    op7: OperatorFunction<F, Err, G, Err>,
+  ): Observable<G, Err>
+  pipe<A, B, C, D, E, F, G, H>(
+    op1: OperatorFunction<Ok, Err, A, Err>,
+    op2: OperatorFunction<A, Err, B, Err>,
+    op3: OperatorFunction<B, Err, C, Err>,
+    op4: OperatorFunction<C, Err, D, Err>,
+    op5: OperatorFunction<D, Err, E, Err>,
+    op6: OperatorFunction<E, Err, F, Err>,
+    op7: OperatorFunction<F, Err, G, Err>,
+    op8: OperatorFunction<G, Err, H, Err>,
+  ): Observable<H, Err>
+  pipe<A, B, C, D, E, F, G, H, I>(
+    op1: OperatorFunction<Ok, Err, A, Err>,
+    op2: OperatorFunction<A, Err, B, Err>,
+    op3: OperatorFunction<B, Err, C, Err>,
+    op4: OperatorFunction<C, Err, D, Err>,
+    op5: OperatorFunction<D, Err, E, Err>,
+    op6: OperatorFunction<E, Err, F, Err>,
+    op7: OperatorFunction<F, Err, G, Err>,
+    op8: OperatorFunction<G, Err, H, Err>,
+    op9: OperatorFunction<H, Err, I, Err>,
+  ): Observable<I, Err>
+  /* Longer chains still compose; type them by hand from the result. */
+  pipe<A, B, C, D, E, F, G, H, I>(
+    op1: OperatorFunction<Ok, Err, A, Err>,
+    op2: OperatorFunction<A, Err, B, Err>,
+    op3: OperatorFunction<B, Err, C, Err>,
+    op4: OperatorFunction<C, Err, D, Err>,
+    op5: OperatorFunction<D, Err, E, Err>,
+    op6: OperatorFunction<E, Err, F, Err>,
+    op7: OperatorFunction<F, Err, G, Err>,
+    op8: OperatorFunction<G, Err, H, Err>,
+    op9: OperatorFunction<H, Err, I, Err>,
+    ...ops: Array<OperatorFunction<any, any, any, any>>
+  ): Observable<unknown, Err>
 
   static withEmitters<Ok, Err = never>(): {
     observable: Observable<Ok, Err>
@@ -78,3 +117,19 @@ export declare class Observable<Ok, Err = never> {
     complete: () => void
   }
 }
+
+/* A state container: values pushed through `next` run through `pipeline`,
+ * and the latest result is replayed to each new subscriber. */
+export declare function state<In, Out>(
+  pipeline: (source: Observable<In>) => Observable<Out>,
+): readonly [value: Observable<Out>, set: (value: In) => void, complete: () => void]
+
+/* Resolve with the first value, or undefined if the source completes without one. */
+export declare function firstValueFrom<T>(source: Observable<T>): Promise<T | undefined>
+
+/* Emit a promise's value, or an iterable's elements in order, then complete. */
+export declare function from<T>(source: Promise<T>): Observable<T>
+export declare function from<T>(source: Iterable<T>): Observable<T>
+
+/* Emit the given values, then complete. */
+export declare function of<T>(...values: T[]): Observable<T>

package/runtime/pwm/types.ts

@@ -1,29 +1,49 @@
+/* mikro/pwm, declared here and implemented in C (mik_pwm.cpp). */
+
+import type {GpioInUse} from '../gpio/types.js'
 import type {Result} from '../result/types.js'
 
 export interface PwmOptions {
-  /** Frequency in Hz */
+  /** Frequency in Hz, 1 to 40000000 */
   freq: number
   /** Initial duty cycle, 0.0–1.0. Defaults to 0. */
   duty?: number
 }
 
 export type PwmError =
+  | GpioInUse
+  | {name: 'InvalidGpio'; message: string}
+  | {name: 'InvalidParam'; message: string}
   | {name: 'NoChannel'; message: string}
   | {name: 'NoTimer'; message: string}
   | {name: 'ConfigFailed'; message: string}
-  | {name: 'NotActive'}
   | {name: 'DutyFailed'; message: string}
   | {name: 'FreqFailed'; message: string}
   | {name: 'FadeFailed'; message: string}
 
-export declare class Pwm {
-  constructor(pin: number, options: PwmOptions)
-  /** Get or set duty cycle (0.0–1.0) */
-  duty(value?: number): Result<number, PwmError>
-  /** Get or set frequency in Hz */
-  freq(value?: number): Result<number, PwmError>
-  /** Hardware fade to target duty over duration. Returns promise with result. */
+/**
+ * @public
+ */
+export interface Pwm {
+  /** The current duty cycle (0.0–1.0) */
+  duty(): Result<number, PwmError>
+  /** Set the duty cycle (0.0–1.0) */
+  duty(value: number): Result<void, PwmError>
+  /** The current frequency in Hz */
+  freq(): Result<number, PwmError>
+  /** Set the frequency in Hz */
+  freq(value: number): Result<void, PwmError>
+  /** Hardware fade to a target duty over a duration. Resolves when the fade completes, or with
+   *  `ok()` when `end()` stops it. */
   fade(targetDuty: number, durationMs: number): Promise<Result<void, PwmError>>
-  /** Stop PWM and release the channel */
-  end(): Result<void, PwmError>
+  /** Stops the output and releases the GPIO pin. Calling it again does nothing. Afterwards setters
+   *  and `fade()` do nothing and getters return the last value; the first such call prints a
+   *  warning. */
+  end(): void
 }
+
+/**
+ * Claims a GPIO pin as a PWM output.
+ * @public
+ */
+export declare function Pwm(gpio: number, options: PwmOptions): Result<Pwm, PwmError>

package/runtime/result/native-result.node-shim.ts

@@ -20,7 +20,7 @@ const proto = {
   orDefault(this: {ok: boolean; value?: unknown; error?: unknown}, defaultValue: unknown) {
     return this.ok ? this.value : defaultValue
   },
-  orPanic(this: {ok: boolean; value?: unknown; error?: unknown}, message: string) {
+  orPanic(this: {ok: boolean; value?: unknown; error?: unknown}, message?: string) {
     if (this.ok) return this.value
     const panic = new Error(message)
     panic.name = 'PanicError'

package/runtime/result/types.ts

@@ -1,5 +1,5 @@
 export declare class PanicError extends Error {
-  constructor(message: string, options?: {cause?: unknown})
+  constructor(message?: string, options?: {cause?: unknown})
 }
 
 export interface OkResult<T> {
@@ -12,8 +12,8 @@ export interface OkResult<T> {
   match<A, B>(handlers: {ok: (value: T) => A; err: (error: never) => B}): A
   /** Get the value, or return the default if this is an Err. */
   orDefault<D>(defaultValue: D): T | D
-  /** Get the value, or panic with the given message if this is an Err. */
-  orPanic(message: string): T
+  /** Get the value, or panic if this is an Err. The error is included as cause. */
+  orPanic(message?: string): T
 }
 
 export interface ErrResult<E> {
@@ -26,8 +26,8 @@ export interface ErrResult<E> {
   match<A, B>(handlers: {ok: (value: never) => A; err: (error: E) => B}): B
   /** Return the default value since this is an Err. */
   orDefault<D>(defaultValue: D): D
-  /** Always panics with the given message since this is an Err. The error is included as cause. */
-  orPanic(message: string): never
+  /** Always panics since this is an Err. The error is included as cause. */
+  orPanic(message?: string): never
 }
 
 export type Result<T, E> = OkResult<T> | ErrResult<E>

package/runtime/sleep/types.ts

@@ -1,13 +1,13 @@
 export type WakeupLevel = 'high' | 'low'
 
-/** A GPIO pin number that must be RTC-capable for deep-sleep wake.
+/** A GPIO number that must be RTC-capable for deep-sleep wake.
  *  Set varies per chip:
  *  - ESP32-C6 / H2: 0–7 (LP_GPIO0–LP_GPIO7)
  *  - ESP32-C3: 0–5
  *  - ESP32-S2 / S3: 0–21 (LP_IO0–LP_IO21)
  *  - ESP32: subset of 0–39 (see datasheet for RTC_GPIO mapping)
  *
- *  Not statically validated — passing a non-RTC pin throws at runtime.
+ *  Not statically validated: passing a non-RTC GPIO throws at runtime.
  */
 export type RtcGpio = number
 
@@ -16,9 +16,11 @@ export type LightWakeupSources = {
   /** Wake after this many milliseconds. Fractional values are allowed
    *  (e.g. `0.01` = 10 µs). */
   timer?: number
-  /** Wake when `pin` reaches `level`. Any GPIO works — no RTC-capable
-   *  constraint. */
-  gpio?: {pin: number; level: WakeupLevel}
+  /** Wake when the GPIO numbered `gpio` reaches `level`. Any GPIO works; it
+   *  does not need to be RTC-capable. Only one GPIO can wake the chip. */
+  gpio?: number
+  /** The level that wakes the chip. Required with `gpio`. */
+  level?: WakeupLevel
 }
 
 /** Sources that can wake the chip from deep sleep. */
@@ -27,8 +29,8 @@ export type DeepWakeupSources = {
   timer?: number
   /** Wake on a single RTC GPIO. ESP32 / S2 / S3 only — throws on
    *  C3 / C6 / H2 (use `ext1` instead). */
-  ext0?: {pin: RtcGpio; level: WakeupLevel}
-  /** Wake when any of `pins` matches `mode`. Pins must be RTC-capable.
+  ext0?: {gpio: RtcGpio; level: WakeupLevel}
+  /** Wake when any of `gpios` matches `mode`. They must be RTC-capable.
    *
    *  Caveat — original ESP32 chip only: the EXT1 hardware on the
    *  original ESP32 cannot honor "any-low" with more than one pin (the
@@ -36,7 +38,7 @@ export type DeepWakeupSources = {
    *  Multi-pin `{mode: 'any-low'}` throws on ESP32; single-pin works,
    *  and `'any-high'` works for any pin count. Every newer chip
    *  (C3, C5, C6, S2, S3, …) supports multi-pin `'any-low'` natively. */
-  ext1?: {pins: RtcGpio[]; mode: 'any-low' | 'any-high'}
+  ext1?: {gpios: RtcGpio[]; mode: 'any-low' | 'any-high'}
 }
 
 /**

package/runtime/spi/types.ts

@@ -1,3 +1,6 @@
+/* mikro/spi, declared here and implemented in C (mik_spi.cpp). */
+
+import type {GpioInUse} from '../gpio/types.js'
 import type {Result} from '../result/types.js'
 
 /**
@@ -13,30 +16,29 @@ export interface SpiOptions {
 }
 
 export type SpiError =
+  | GpioInUse
+  | {name: 'InvalidGpio'; message: string}
+  | {name: 'InvalidParam'; message: string}
   | {name: 'BusInitFailed'; message: string}
   | {name: 'AddDeviceFailed'; message: string}
-  | {name: 'NotStarted'}
-  | {name: 'MissingPins'}
   | {name: 'TransferFailed'; message: string}
   | {name: 'WriteFailed'; message: string}
 
 /**
  * @public
  */
-export declare const Spi: {
-  prototype: Spi
-  new (hostNo: 1 | 2, options: SpiOptions): Spi
+export interface Spi {
+  /** Full-duplex transfer: sends `data` and returns the bytes received at the same time. */
+  transfer(data: Uint8Array): Result<Uint8Array, SpiError>
+  /** Write-only transfer. */
+  write(data: Uint8Array): Result<void, SpiError>
+  /** Frees the bus and releases its GPIO pins. Calling it again does nothing. Afterwards `write()`
+   *  does nothing and `transfer()` returns an empty array; the first such call prints a warning. */
+  end(): void
 }
 
 /**
+ * Claims the pins and starts an SPI bus on a host controller.
  * @public
  */
-export interface Spi {
-  begin(): Result<void, SpiError>
-
-  end(): Result<void, SpiError>
-
-  transfer(data: Uint8Array): Result<Uint8Array, SpiError>
-
-  write(data: Uint8Array): Result<void, SpiError>
-}
+export declare function Spi(host: number, options: SpiOptions): Result<Spi, SpiError>

package/runtime/uart/types.ts

@@ -1,3 +1,6 @@
+/* mikro/uart, declared here and implemented in C (mik_uart.cpp). */
+
+import type {GpioInUse} from '../gpio/types.js'
 import type {Result} from '../result/types.js'
 
 /**
@@ -32,12 +35,13 @@ export interface UartRxOnlyOptions extends UartBaseOptions {
 }
 
 export type UartError =
+  | GpioInUse
+  | {name: 'InvalidGpio'; message: string}
+  | {name: 'InvalidParam'; message: string}
   | {name: 'DriverInstallFailed'; message: string}
   | {name: 'SetPinFailed'; message: string}
-  | {name: 'InvalidParam'; message: string}
   | {name: 'WriteFailed'; message: string}
   | {name: 'ReadFailed'; message: string}
-  | {name: 'NotStarted'}
   | {name: 'AlreadyReading'}
   | {name: 'NoRxPin'}
   | {name: 'NoTxPin'}
@@ -54,10 +58,8 @@ export interface UartTx {
  */
 export interface UartRx {
   /**
-   * Open a Result-yielding async iterable of received chunks. Mid-stream
-   * failures (driver fault, port closed mid-iteration) arrive as a single
-   * terminal `err(UartError)` item rather than throwing — composes with
-   * stream/* combinators and other Result-based APIs.
+   * Open a Result-yielding async iterable of received chunks. The iterable
+   * completes when `end()` is called.
    */
   read(): Result<AsyncIterable<Result<Uint8Array, UartError>>, UartError>
 }
@@ -65,17 +67,27 @@ export interface UartRx {
 /**
  * @public
  */
-export interface UartBase {
-  begin(): Result<void, UartError>
-  end(): Result<void, UartError>
+export interface Uart {
+  /** Uninstalls the driver and releases the GPIO pins. Calling it again does nothing. An active
+   *  `read()` iterable completes. Afterwards `write()` does nothing and `read()` returns an
+   *  iterable that completes at once; the first such call prints a warning. */
+  end(): void
 }
 
 /**
+ * Claims the pins and installs the UART driver on a port. The methods available depend on which
+ * of `tx` and `rx` are given.
  * @public
  */
-export declare const Uart: {
-  prototype: UartBase
-  new (port: number, options: UartTxRxOptions): UartBase & UartTx & UartRx
-  new (port: number, options: UartTxOnlyOptions): UartBase & UartTx
-  new (port: number, options: UartRxOnlyOptions): UartBase & UartRx
-}
+export declare function Uart(
+  port: number,
+  options: UartTxRxOptions,
+): Result<Uart & UartTx & UartRx, UartError>
+export declare function Uart(
+  port: number,
+  options: UartTxOnlyOptions,
+): Result<Uart & UartTx, UartError>
+export declare function Uart(
+  port: number,
+  options: UartRxOnlyOptions,
+): Result<Uart & UartRx, UartError>