@mikrojs/native 0.6.0-pr-70.gd2fdc0d → 0.6.0-pr-72.g464c29c

package/CMakeLists.txt

@@ -50,7 +50,6 @@ set(MIKROJS_CORE_SOURCES
     src/mik_repl.cpp
     src/mik_app_config.cpp
     src/mik_udp.cpp
-    src/mik_observable.cpp
 )
 
 add_library(mikrojs STATIC
@@ -81,7 +80,7 @@ endif()
 include(cmake/mikrojs_bytecode.cmake)
 mikrojs_generate_bytecode(
     RUNTIME_DIR "${CMAKE_CURRENT_SOURCE_DIR}/runtime"
-    MODULES cbor env result schema fs http/helpers http/request i2c kv/nvs kv/rtc kv/shared neopixel observable observable/operators pin pwm reader sleep spi sntp stdio stream sys test uart udp wifi
+    MODULES cbor env result schema fs http/helpers http/request i2c kv/nvs kv/rtc kv/shared neopixel pin pwm reader sleep spi sntp stdio stream sys test uart udp wifi
     MODULE_PREFIX "mikrojs"
     SYMBOL_PREFIX "mikrojs"
     TARGET gen_bytecode
@@ -162,7 +161,6 @@ if(BUILD_TESTING)
         test/stream_test.cpp
         test/runtime_recycle_test.cpp
         test/udp_test.cpp
-        test/observable_test.cpp
     )
 
     target_link_libraries(mikrojs_tests PRIVATE mikrojs)

package/include/mikrojs/private.h

@@ -215,9 +215,6 @@ JSModuleDef* mik__result_init(JSContext* ctx);
 /* UDP module (mik_udp.cpp) */
 JSModuleDef* mik__udp_init(JSContext* ctx);
 
-/* Observable module (mik_observable.cpp) */
-JSModuleDef* mik__observable_init(JSContext* ctx);
-
 bool mik__repl_is_evaluating(void);
 
 /* REPL protocol mode (mik_repl.cpp) — used by mik_console.cpp, mik_stdio.cpp */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikrojs/native",
-  "version": "0.6.0-pr-70.gd2fdc0d",
+  "version": "0.6.0-pr-72.g464c29c",
   "description": "Mikro.js C++ runtime library and Node.js native addon",
   "keywords": [
     "esp32",
@@ -56,8 +56,6 @@
     "./runtime/kv/shared": "./runtime/kv/shared.ts",
     "./runtime/kv/types": "./runtime/kv/types.ts",
     "./runtime/neopixel/types": "./runtime/neopixel/types.ts",
-    "./runtime/observable/operators": "./runtime/observable/operators.ts",
-    "./runtime/observable/types": "./runtime/observable/types.ts",
     "./runtime/pin/types": "./runtime/pin/types.ts",
     "./runtime/pwm/types": "./runtime/pwm/types.ts",
     "./runtime/reader/types": "./runtime/reader/types.ts",
@@ -78,7 +76,7 @@
     "cmake-js": "^8.0.0",
     "node-addon-api": "^8.7.0",
     "node-gyp-build": "^4.8.4",
-    "@mikrojs/quickjs": "0.6.0-pr-70.gd2fdc0d"
+    "@mikrojs/quickjs": "0.6.0-pr-72.g464c29c"
   },
   "devDependencies": {
     "@swc/core": "^1.15.30",

package/runtime/ble/ble.ts

@@ -1,8 +1,6 @@
-import {Observable} from 'mikrojs/observable'
 import {err, ok} from 'mikrojs/result'
 import {Ble as NativeBle} from 'native:ble'
 
-import type {Subscriber} from '../observable/types.js'
 import type {Result} from '../result/types.js'
 import type {
   AdvertiseHandle,
@@ -11,9 +9,8 @@ import type {
   BleError,
   Characteristic,
   CharacteristicProperty,
-  ConnectionInfo,
-  MtuInfo,
   Peripheral,
+  PeripheralEventMap,
   Service,
 } from './types.js'
 import {parseUuid} from './uuid.js'
@@ -143,32 +140,6 @@ function normalizeServices(services: Service[]) {
 
 const native = new NativeBle()
 
-/* Lazy-attach: native.on runs only after the first JS subscriber and is
- * removed when the last one leaves. Same pattern as wifi.ts; see the note
- * there for the mbedTLS internal-RAM rationale. */
-function lazyEvent<T>(eventName: string): Observable<T> {
-  const subscribers: Subscriber<T>[] = []
-  function handler(value: unknown): void {
-    const snapshot = subscribers.slice()
-    for (const s of snapshot) {
-      if (!s.closed) s.next(value as T)
-    }
-  }
-  return new Observable<T>((sub) => {
-    subscribers.push(sub)
-    if (subscribers.length === 1) {
-      native.on(eventName, handler)
-    }
-    sub.addTeardown(() => {
-      const i = subscribers.indexOf(sub)
-      if (i >= 0) subscribers.splice(i, 1)
-      if (subscribers.length === 0) {
-        native.off(eventName, handler)
-      }
-    })
-  })
-}
-
 const ble: Ble = {
   get name(): string {
     return native.getName()
@@ -248,9 +219,13 @@ const peripheral: Peripheral = {
     return ok(handle)
   },
 
-  onConnect: lazyEvent<ConnectionInfo>('connect'),
-  onDisconnect: lazyEvent<ConnectionInfo>('disconnect'),
-  onMtu: lazyEvent<MtuInfo>('mtu'),
+  on<K extends keyof PeripheralEventMap>(event: K, listener: PeripheralEventMap[K]) {
+    native.on(event, listener as (...args: unknown[]) => void)
+  },
+
+  off<K extends keyof PeripheralEventMap>(event: K, listener: PeripheralEventMap[K]) {
+    native.off(event, listener as (...args: unknown[]) => void)
+  },
 }
 
 export {ble, peripheral}

package/runtime/ble/types.ts

@@ -1,4 +1,3 @@
-import type {Observable} from '../observable/types.js'
 import type {Result} from '../result/types.js'
 
 /** Advertising interval range in milliseconds. */
@@ -172,15 +171,23 @@ export interface MtuInfo {
   mtu: number
 }
 
+export interface PeripheralEventMap {
+  connect: (info: ConnectionInfo) => void
+  disconnect: (info: ConnectionInfo) => void
+  mtu: (info: MtuInfo) => void
+}
+
 export interface Peripheral {
   /** Start advertising. Returns a handle whose `stop()` ends this session. */
   advertise(options?: AdvertiseOptions): Promise<Result<AdvertiseHandle, BleError>>
-  /** Emits when a central connects. Subscribers are dispatched on the JS loop thread. */
-  readonly onConnect: Observable<ConnectionInfo>
-  /** Emits when a central disconnects. */
-  readonly onDisconnect: Observable<ConnectionInfo>
-  /** Emits when a connected central renegotiates its ATT MTU. */
-  readonly onMtu: Observable<MtuInfo>
+  /**
+   * Register a listener for a peripheral lifecycle event. Listeners are
+   * called on the JS loop thread in registration order. Safe to register
+   * before calling `advertise()`.
+   */
+  on<K extends keyof PeripheralEventMap>(event: K, listener: PeripheralEventMap[K]): void
+  /** Remove a previously-registered listener. */
+  off<K extends keyof PeripheralEventMap>(event: K, listener: PeripheralEventMap[K]): void
 }
 
 export declare const ble: Ble

package/runtime/internal.d.ts

@@ -25,10 +25,6 @@ declare module 'native:result' {
   export function err<E>(error: E): ErrResult<E>
 }
 
-declare module 'native:observable' {
-  export {Observable} from '@mikrojs/native/runtime/observable/types'
-}
-
 declare module 'native:sys' {
   import type {JsMemoryUsage} from './sys/types.js'
   export function evalScript(code: string): Promise<{value: unknown}>

package/runtime/udp/types.ts

@@ -1,4 +1,3 @@
-import type {Observable} from '../observable/types.js'
 import type {Result} from '../result/types.js'
 
 export type UdpFamily = 'ipv4' | 'ipv6'
@@ -32,31 +31,19 @@ export type UdpError =
   | {name: 'Closed'}
   | {name: 'NotBound'}
 
-/** Inbound datagram delivered via `socket.onMessage`. */
-export interface UdpMessage {
-  msg: Uint8Array
-  from: PeerAddress
-}
-
 export interface UdpSocket {
   readonly port: number
   readonly family: UdpFamily | 'dual'
   /**
    * Counter incremented each time an inbound datagram is dropped:
    * - the per-socket queue is full,
-   * - no subscriber is attached to `onMessage` when a packet arrives,
+   * - no `onMessage` handler is set when a packet arrives,
    * - or the datagram is larger than the 1500-byte receive buffer
    *   (typical Ethernet MTU; covers CoAP / mDNS / SNTP / DNS).
    */
   dropped: number
 
-  /**
-   * Stream of inbound datagrams. Subscribing attaches the native dispatch
-   * once the first subscriber is added; the last `unsubscribe()` detaches
-   * it again. Multiple subscribers fan out from one native registration.
-   * Completes when `close()` is called.
-   */
-  readonly onMessage: Observable<UdpMessage>
+  onMessage: ((msg: Uint8Array, from: PeerAddress) => void) | null
 
   send(data: Uint8Array | string, to: PeerAddress): Promise<Result<void, UdpError>>
   joinMulticastGroup(group: MulticastGroup): Result<void, UdpError>

package/runtime/udp/udp.ts

@@ -1,10 +1,8 @@
-import {Observable} from 'mikrojs/observable'
 import {ok} from 'mikrojs/result'
 import {bind as nativeBind, type NativeUdpSocket} from 'native:udp'
 
-import type {Subscriber} from '../observable/types.js'
 import type {Result} from '../result/types.js'
-import type {BindOptions, MulticastGroup, UdpError, UdpMessage, UdpSocket} from './types.js'
+import type {BindOptions, MulticastGroup, PeerAddress, UdpError, UdpSocket} from './types.js'
 
 const utf8 = new TextEncoder()
 
@@ -13,37 +11,7 @@ function toBytes(data: Uint8Array | string): Uint8Array {
 }
 
 function makeSocket(handle: NativeUdpSocket): UdpSocket {
-  /* Lazy native attach: keep handle.setOnMessage in sync with whether any
-   * JS subscriber is listening. With zero subscribers, the native side
-   * skips JS dispatch and increments the dropped counter for inbound
-   * packets — preserving the pre-Observable behavior of unset onMessage
-   * silently discarding traffic. */
-  const subscribers: Subscriber<UdpMessage>[] = []
-  let closed = false
-
-  const onMessage = new Observable<UdpMessage>((sub) => {
-    if (closed) {
-      sub.complete()
-      return
-    }
-    subscribers.push(sub)
-    if (subscribers.length === 1) {
-      handle.setOnMessage((msg, from) => {
-        /* Snapshot so unsubscribes during dispatch don't shift indices. */
-        const snapshot = subscribers.slice()
-        for (const s of snapshot) {
-          if (!s.closed) s.next({msg, from})
-        }
-      })
-    }
-    sub.addTeardown(() => {
-      const i = subscribers.indexOf(sub)
-      if (i >= 0) subscribers.splice(i, 1)
-      if (subscribers.length === 0 && !closed) {
-        handle.setOnMessage(null)
-      }
-    })
-  })
+  let onMessage: ((msg: Uint8Array, from: PeerAddress) => void) | null = null
 
   const sock: UdpSocket = {
     get port() {
@@ -58,7 +26,13 @@ function makeSocket(handle: NativeUdpSocket): UdpSocket {
     set dropped(value: number) {
       handle.dropped = value
     },
-    onMessage,
+    get onMessage() {
+      return onMessage
+    },
+    set onMessage(fn) {
+      onMessage = fn
+      handle.setOnMessage(fn)
+    },
     send(data, to) {
       return handle.send(toBytes(data), to)
     },
@@ -69,16 +43,6 @@ function makeSocket(handle: NativeUdpSocket): UdpSocket {
       return handle.leaveMulticastGroup(group.address)
     },
     close() {
-      if (closed) return
-      closed = true
-      handle.setOnMessage(null)
-      /* Complete any active subscriptions. Walk a snapshot in case a
-       * complete handler unsubscribes a sibling. */
-      const snapshot = subscribers.slice()
-      subscribers.length = 0
-      for (const s of snapshot) {
-        if (!s.closed) s.complete()
-      }
       handle.close()
     },
   }

package/runtime/wifi/types.ts

@@ -1,4 +1,3 @@
-import type {Observable} from '../observable/types.js'
 import type {Result} from '../result/types.js'
 
 export type WifiStatus =
@@ -88,6 +87,17 @@ export interface ApStartOptions {
   maxConnections?: number
 }
 
+export interface WifiEventMap {
+  connect: (info: WifiConnectionInfo) => void
+  disconnect: (reason: WifiDisconnectReason) => void
+  'rssi-low': (rssi: number) => void
+}
+
+export interface ApEventMap {
+  'station-connect': (info: ApStationInfo) => void
+  'station-disconnect': (info: ApStationInfo) => void
+}
+
 export type WifiError =
   | {name: 'InitFailed'; message: string}
   | {name: 'CountryNotSet'}
@@ -112,8 +122,8 @@ export interface WifiAp {
   readonly stations: ApStationInfo[]
   deauthStation(mac: string): Result<void, WifiError>
   inactiveTimeout: number
-  readonly onStationConnect: Observable<ApStationInfo>
-  readonly onStationDisconnect: Observable<ApStationInfo>
+  on<K extends keyof ApEventMap>(event: K, listener: ApEventMap[K]): void
+  off<K extends keyof ApEventMap>(event: K, listener: ApEventMap[K]): void
 }
 
 export interface Wifi {
@@ -125,9 +135,8 @@ export interface Wifi {
   isConnected: boolean
   scan(opts?: ScanOptions): Promise<Result<ScanResult[], WifiError>>
 
-  readonly onConnect: Observable<WifiConnectionInfo>
-  readonly onDisconnect: Observable<WifiDisconnectReason>
-  readonly onRssiLow: Observable<number>
+  on<K extends keyof WifiEventMap>(event: K, listener: WifiEventMap[K]): void
+  off<K extends keyof WifiEventMap>(event: K, listener: WifiEventMap[K]): void
 
   readonly mac: string
   hostname: string | undefined

package/runtime/wifi/wifi.ts

@@ -1,10 +1,9 @@
-import {Observable} from 'mikrojs/observable'
 import {err, ok} from 'mikrojs/result'
 import {Wifi as NativeWifi} from 'native:wifi'
 
-import type {Subscriber} from '../observable/types.js'
 import type {Result} from '../result/types.js'
 import type {
+  ApEventMap,
   ApStartOptions,
   ApStationInfo,
   IpConfig,
@@ -16,8 +15,8 @@ import type {
   WifiAp,
   WifiConnectionInfo,
   WifiCountryCode,
-  WifiDisconnectReason,
   WifiError,
+  WifiEventMap,
   WifiStatus,
 } from './types.js'
 
@@ -38,36 +37,6 @@ const StatusFromCode = new Map<number, WifiStatus>(
 
 const native = new NativeWifi()
 
-/* Lazy-attach Observable: native.on is only called once a JS subscriber
- * appears, and native.off runs when the last one unsubscribes. Code paths
- * that import wifi but don't subscribe (e.g. a fetch-only flow) take the
- * exact same internal-RAM path as before observables existed — important
- * because mbedTLS handshake needs ~16 KB contiguous internal SRAM and
- * each eager closure pinned at module load chips into that headroom. */
-function lazyEvent<T>(eventName: string): Observable<T> {
-  const subscribers: Subscriber<T>[] = []
-  function handler(value: unknown): void {
-    /* Snapshot so unsubscribes during dispatch don't shift indices. */
-    const snapshot = subscribers.slice()
-    for (const s of snapshot) {
-      if (!s.closed) s.next(value as T)
-    }
-  }
-  return new Observable<T>((sub) => {
-    subscribers.push(sub)
-    if (subscribers.length === 1) {
-      native.on(eventName, handler)
-    }
-    sub.addTeardown(() => {
-      const i = subscribers.indexOf(sub)
-      if (i >= 0) subscribers.splice(i, 1)
-      if (subscribers.length === 0) {
-        native.off(eventName, handler)
-      }
-    })
-  })
-}
-
 const ap: WifiAp = {
   start(options: ApStartOptions): Result<void, WifiError> {
     return native.apStart(options as Parameters<typeof native.apStart>[0])
@@ -102,8 +71,13 @@ const ap: WifiAp = {
     native.apSetInactiveTimeout(seconds)
   },
 
-  onStationConnect: lazyEvent<ApStationInfo>('station-connect'),
-  onStationDisconnect: lazyEvent<ApStationInfo>('station-disconnect'),
+  on<K extends keyof ApEventMap>(event: K, listener: ApEventMap[K]) {
+    native.on(event, listener as (...args: unknown[]) => void)
+  },
+
+  off<K extends keyof ApEventMap>(event: K, listener: ApEventMap[K]) {
+    native.off(event, listener as (...args: unknown[]) => void)
+  },
 }
 
 const MAX_CONNECT_RETRIES = 5
@@ -161,9 +135,13 @@ const wifi: Wifi = {
     return ok(asyncResult.value as ScanResult[])
   },
 
-  onConnect: lazyEvent<WifiConnectionInfo>('connect'),
-  onDisconnect: lazyEvent<WifiDisconnectReason>('disconnect'),
-  onRssiLow: lazyEvent<number>('rssi-low'),
+  on<K extends keyof WifiEventMap>(event: K, listener: WifiEventMap[K]) {
+    native.on(event, listener as (...args: unknown[]) => void)
+  },
+
+  off<K extends keyof WifiEventMap>(event: K, listener: WifiEventMap[K]) {
+    native.off(event, listener as (...args: unknown[]) => void)
+  },
 
   get mac(): string {
     const result = native.mac()

package/src/mikrojs.cpp

@@ -317,7 +317,6 @@ MIKRuntime* MIK_NewRuntimeInternal(MIKRunOptions* options) {
     mik__result_init(ctx);
     mik__cbor_init(ctx);
     mik__udp_init(ctx);
-    mik__observable_init(ctx);
 
     /* Native mikrojs modules (replace bytecode builtins) */
     mik__inspect_register(ctx);

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

@@ -1,220 +0,0 @@
-// Host-side shim for `native:observable`, used only in vitest (Node) where
-// the mikrojs C runtime isn't available. Keep in sync with mik_observable.cpp.
-//
-// Mirrors the locked design in .claude/plans/observable.md:
-// - subscribe() returns a Subscription with unsubscribe() (no AbortSignal)
-// - no error channel — throws inside dispatch or teardown are caught at the
-//   boundary, isolated to the offending subscriber, and re-thrown
-//   asynchronously via setTimeout(0) so the synchronous producer keeps
-//   running but the bug eventually surfaces (and on device, halts the
-//   runtime via the existing unhandled-rejection path)
-// - sync emission allowed
-// - pipe-only composition (operators live in operators.ts)
-// - withEmitters() factory: {observable, next, complete}
-
-/* Catch a thrown error and re-throw it on the next tick. The synchronous
- * caller keeps going (other subscribers receive the value, remaining
- * teardowns run); the error eventually surfaces as an uncaught exception. */
-function panicAsync(err: unknown): void {
-  setTimeout(() => {
-    throw err
-  }, 0)
-}
-
-class Subscriber<T> {
-  closed = false
-  private next_fn: ((v: T) => void) | undefined
-  private complete_fn: (() => void) | undefined
-  private teardowns: Array<() => void> = []
-
-  constructor(observer: unknown) {
-    if (observer == null) return
-    if (typeof observer === 'function') {
-      this.next_fn = observer as (v: T) => void
-    } else if (typeof observer === 'object') {
-      const o = observer as {next?: (v: T) => void; complete?: () => void}
-      if (typeof o.next === 'function') this.next_fn = o.next
-      if (typeof o.complete === 'function') this.complete_fn = o.complete
-    } else {
-      throw new TypeError('subscribe: observer must be a function, object, undefined, or null')
-    }
-  }
-
-  next(value: T): void {
-    if (this.closed) return
-    if (this.next_fn) {
-      try {
-        this.next_fn(value)
-      } catch (err) {
-        panicAsync(err)
-      }
-    }
-  }
-
-  complete(): void {
-    if (this.closed) return
-    this.closed = true
-    if (this.complete_fn) {
-      try {
-        this.complete_fn()
-      } catch (err) {
-        panicAsync(err)
-      }
-    }
-    this.runTeardowns()
-  }
-
-  addTeardown(fn: () => void): void {
-    if (typeof fn !== 'function') {
-      throw new TypeError('addTeardown: argument must be a function')
-    }
-    if (this.closed) {
-      try {
-        fn()
-      } catch (err) {
-        panicAsync(err)
-      }
-      return
-    }
-    this.teardowns.push(fn)
-  }
-
-  // Used by Subscription.unsubscribe — silent (no observer.complete call).
-  closeSilently(): void {
-    if (this.closed) return
-    this.closed = true
-    this.runTeardowns()
-  }
-
-  private runTeardowns(): void {
-    const list = this.teardowns
-    this.teardowns = []
-    for (let i = list.length - 1; i >= 0; i--) {
-      try {
-        list[i]!()
-      } catch (err) {
-        panicAsync(err)
-      }
-    }
-  }
-}
-
-class Subscription {
-  constructor(private subscriber: Subscriber<unknown>) {}
-  unsubscribe(): void {
-    this.subscriber.closeSilently()
-  }
-}
-
-type SubscribeCallback<T> = (sub: Subscriber<T>) => void
-
-export class Observable<Ok, Err = never> {
-  // The shim doesn't actually use `_phantom` at runtime; the type parameters are
-  // purely for type-level alignment with the public interface.
-  declare readonly _phantom: [Ok, Err]
-  #cb: SubscribeCallback<unknown>
-
-  constructor(cb: SubscribeCallback<unknown>) {
-    if (typeof cb !== 'function') {
-      throw new TypeError('Observable: constructor requires a function argument')
-    }
-    this.#cb = cb
-  }
-
-  subscribe(observer?: unknown): Subscription {
-    const sub = new Subscriber<unknown>(observer)
-    try {
-      this.#cb(sub)
-    } catch (err) {
-      sub.closeSilently()
-      throw err
-    }
-    return new Subscription(sub)
-  }
-
-  pipe(...ops: Array<(o: Observable<unknown, unknown>) => Observable<unknown, unknown>>) {
-    let current: Observable<unknown, unknown> = this as unknown as Observable<unknown, unknown>
-    for (const op of ops) {
-      if (typeof op !== 'function') {
-        throw new TypeError('pipe: arguments must be operator functions')
-      }
-      current = op(current)
-    }
-    return current
-  }
-
-  static from(src: unknown): Observable<unknown, unknown> {
-    if (src instanceof Observable) return src
-    if (
-      src != null &&
-      (typeof src === 'object' || typeof src === 'function') &&
-      typeof (src as {then?: unknown}).then === 'function'
-    ) {
-      // Promise-shaped
-      return new Observable<unknown>((sub) => {
-        ;(src as PromiseLike<unknown>).then((value) => {
-          if (sub.closed) return
-          sub.next(value)
-          if (sub.closed) return
-          sub.complete()
-        })
-      })
-    }
-    if (
-      src != null &&
-      (typeof src === 'object' || typeof src === 'string') &&
-      typeof (src as {[Symbol.iterator]?: unknown})[Symbol.iterator] === 'function'
-    ) {
-      return new Observable<unknown>((sub) => {
-        for (const value of src as Iterable<unknown>) {
-          if (sub.closed) return
-          sub.next(value)
-        }
-        if (!sub.closed) sub.complete()
-      })
-    }
-    throw new TypeError('Observable.from: source must be a Promise, Iterable, or Observable')
-  }
-
-  static withEmitters<Ok, Err = never>(): {
-    observable: Observable<Ok, Err>
-    next: (value: unknown) => void
-    complete: () => void
-  } {
-    const subs: Array<Subscriber<unknown>> = []
-    let completed = false
-
-    const observable = new Observable<unknown>((sub) => {
-      if (completed) {
-        sub.complete()
-        return
-      }
-      subs.push(sub)
-      sub.addTeardown(() => {
-        const i = subs.indexOf(sub)
-        if (i >= 0) subs.splice(i, 1)
-      })
-    })
-
-    const next = (value: unknown) => {
-      if (completed) return
-      // Snapshot to be resilient against mid-dispatch unsubscribes.
-      const snapshot = subs.slice()
-      for (const s of snapshot) {
-        if (!s.closed) s.next(value)
-      }
-    }
-
-    const complete = () => {
-      if (completed) return
-      completed = true
-      const snapshot = subs.slice()
-      subs.length = 0
-      for (const s of snapshot) {
-        if (!s.closed) s.complete()
-      }
-    }
-
-    return {observable: observable as unknown as Observable<Ok, Err>, next, complete}
-  }
-}

package/runtime/observable/observable.ts

@@ -1 +0,0 @@
-export {Observable} from 'native:observable'