@pubber-subber/rxjs 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sami Mishal
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,72 @@
+# @pubber-subber/rxjs
+
+Optional RxJS bridge for [`@pubber-subber/core`](https://www.npmjs.com/package/@pubber-subber/core). Turn any topic subscription into an `Observable`. Works with every adapter — the bridge is transport-agnostic.
+
+The bridge is intentionally a separate package so the core stays dependency-free for apps that don't use RxJS.
+
+## Install
+
+```sh
+pnpm add @pubber-subber/core @pubber-subber/rxjs rxjs
+```
+
+`rxjs` is a **peer dependency**. Supports RxJS 7 and 8.
+
+## Quick start
+
+```ts
+import { PubSub } from '@pubber-subber/core';
+import { memory } from '@pubber-subber/memory';
+import { fromTopic } from '@pubber-subber/rxjs';
+
+const pubsub = new PubSub({ adapter: memory() });
+
+const sub = fromTopic<{ id: number }>(pubsub, 'users.created')
+  .subscribe((user) => console.log(user.id));
+
+await pubsub.publish('users.created', { id: 1 });
+
+sub.unsubscribe();    // tears down the underlying pubsub subscription too
+```
+
+## API
+
+```ts
+toObservable<T>(pubsub, topic, meta?): Observable<AdapterMessage<T>>
+fromTopic<T>(pubsub, topic, meta?): Observable<T>
+```
+
+- **`toObservable`** emits the full `AdapterMessage` envelope — `topic`, `payload`, `raw`, `meta`, optional `ack`/`nack`. Use it when you need the envelope.
+- **`fromTopic`** unwraps to just `payload` — the convenience choice when you don't care about the envelope.
+
+Both lazy-create the underlying pubsub subscription on the first observer attach and tear it down on the last unsubscribe.
+
+## Pipelines
+
+The whole point of the bridge is composing with RxJS operators:
+
+```ts
+import { fromTopic } from '@pubber-subber/rxjs';
+import { bufferTime, filter, mergeMap } from 'rxjs';
+
+interface PageView { user: string; path: string; ts: number; }
+
+fromTopic<PageView>(pubsub, 'analytics.pageview')
+  .pipe(
+    filter((v) => !v.path.startsWith('/internal')),
+    bufferTime(250),
+    mergeMap((batch) => writeBatch(batch)),
+  )
+  .subscribe();
+```
+
+## Notes
+
+- **Cancellation race**: teardown is safe even if it races with the initial `subscribe()` call — the bridge tracks a cancellation flag and unsubscribes upstream as soon as it resolves. Subscribing and immediately unsubscribing never throws or leaks.
+- **No `.observe()` on `PubSub`**: adding it would pull RxJS types into core. The function form keeps the coupling one-way; apps that don't use RxJS pay no cost.
+- **Multi-subscriber**: each Observable subscription creates its own underlying pubsub subscription. For transports that fan out anyway (Redis pub/sub, in-memory) this is the expected behavior. For transports with shared subscriptions (GCP Pub/Sub, SQS) this means messages distribute across observers per the broker's semantics.
+- **Errors**: errors from the underlying `pubsub.subscribe()` are emitted via `subscriber.error()`. Errors thrown from RxJS operators bubble up the pipeline as usual; they don't propagate back into the pubsub subscription.
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,66 @@
+'use strict';
+
+var rxjs = require('rxjs');
+
+// src/index.ts
+function toObservable(pubsub, topic, meta) {
+  return new rxjs.Observable((subscriber) => {
+    let handle = null;
+    let cancelled = false;
+    pubsub.subscribe(
+      topic,
+      (msg) => {
+        subscriber.next(msg);
+      },
+      meta
+    ).then((h) => {
+      if (cancelled) {
+        void h.unsubscribe();
+      } else {
+        handle = h;
+      }
+    }).catch((err) => {
+      if (!cancelled) subscriber.error(err);
+    });
+    return () => {
+      cancelled = true;
+      if (handle) {
+        void handle.unsubscribe();
+        handle = null;
+      }
+    };
+  });
+}
+function fromTopic(pubsub, topic, meta) {
+  return new rxjs.Observable((subscriber) => {
+    let handle = null;
+    let cancelled = false;
+    pubsub.subscribe(
+      topic,
+      (msg) => {
+        subscriber.next(msg.payload);
+      },
+      meta
+    ).then((h) => {
+      if (cancelled) {
+        void h.unsubscribe();
+      } else {
+        handle = h;
+      }
+    }).catch((err) => {
+      if (!cancelled) subscriber.error(err);
+    });
+    return () => {
+      cancelled = true;
+      if (handle) {
+        void handle.unsubscribe();
+        handle = null;
+      }
+    };
+  });
+}
+
+exports.fromTopic = fromTopic;
+exports.toObservable = toObservable;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"names":["Observable"],"mappings":";;;;;AAUO,SAAS,YAAA,CACd,MAAA,EACA,KAAA,EACA,IAAA,EAC+B;AAC/B,EAAA,OAAO,IAAIA,eAAA,CAA8B,CAAC,UAAA,KAAe;AACvD,IAAA,IAAI,MAAA,GAAoC,IAAA;AACxC,IAAA,IAAI,SAAA,GAAY,KAAA;AAEhB,IAAA,MAAA,CACG,SAAA;AAAA,MACC,KAAA;AAAA,MACA,CAAC,GAAA,KAAQ;AACP,QAAA,UAAA,CAAW,KAAK,GAAG,CAAA;AAAA,MACrB,CAAA;AAAA,MACA;AAAA,KACF,CACC,IAAA,CAAK,CAAC,CAAA,KAAM;AACX,MAAA,IAAI,SAAA,EAAW;AACb,QAAA,KAAK,EAAE,WAAA,EAAY;AAAA,MACrB,CAAA,MAAO;AACL,QAAA,MAAA,GAAS,CAAA;AAAA,MACX;AAAA,IACF,CAAC,CAAA,CACA,KAAA,CAAM,CAAC,GAAA,KAAQ;AACd,MAAA,IAAI,CAAC,SAAA,EAAW,UAAA,CAAW,KAAA,CAAM,GAAG,CAAA;AAAA,IACtC,CAAC,CAAA;AAEH,IAAA,OAAO,MAAM;AACX,MAAA,SAAA,GAAY,IAAA;AACZ,MAAA,IAAI,MAAA,EAAQ;AACV,QAAA,KAAK,OAAO,WAAA,EAAY;AACxB,QAAA,MAAA,GAAS,IAAA;AAAA,MACX;AAAA,IACF,CAAA;AAAA,EACF,CAAC,CAAA;AACH;AAOO,SAAS,SAAA,CACd,MAAA,EACA,KAAA,EACA,IAAA,EACe;AACf,EAAA,OAAO,IAAIA,eAAA,CAAc,CAAC,UAAA,KAAe;AACvC,IAAA,IAAI,MAAA,GAAoC,IAAA;AACxC,IAAA,IAAI,SAAA,GAAY,KAAA;AAEhB,IAAA,MAAA,CACG,SAAA;AAAA,MACC,KAAA;AAAA,MACA,CAAC,GAAA,KAAQ;AACP,QAAA,UAAA,CAAW,IAAA,CAAK,IAAI,OAAO,CAAA;AAAA,MAC7B,CAAA;AAAA,MACA;AAAA,KACF,CACC,IAAA,CAAK,CAAC,CAAA,KAAM;AACX,MAAA,IAAI,SAAA,EAAW;AACb,QAAA,KAAK,EAAE,WAAA,EAAY;AAAA,MACrB,CAAA,MAAO;AACL,QAAA,MAAA,GAAS,CAAA;AAAA,MACX;AAAA,IACF,CAAC,CAAA,CACA,KAAA,CAAM,CAAC,GAAA,KAAQ;AACd,MAAA,IAAI,CAAC,SAAA,EAAW,UAAA,CAAW,KAAA,CAAM,GAAG,CAAA;AAAA,IACtC,CAAC,CAAA;AAEH,IAAA,OAAO,MAAM;AACX,MAAA,SAAA,GAAY,IAAA;AACZ,MAAA,IAAI,MAAA,EAAQ;AACV,QAAA,KAAK,OAAO,WAAA,EAAY;AACxB,QAAA,MAAA,GAAS,IAAA;AAAA,MACX;AAAA,IACF,CAAA;AAAA,EACF,CAAC,CAAA;AACH","file":"index.cjs","sourcesContent":["import type { AdapterMessage, PubSub, SubscriptionHandle } from '@pubber-subber/core';\nimport { Observable } from 'rxjs';\n\n/**\n * Bridge a topic to an RxJS Observable that emits the full `AdapterMessage`.\n *\n * The subscription is created lazily when the first RxJS subscriber attaches,\n * and torn down on unsubscribe. Handles the case where teardown races the\n * underlying `pubsub.subscribe` resolution.\n */\nexport function toObservable<T = unknown>(\n  pubsub: PubSub,\n  topic: string,\n  meta?: unknown,\n): Observable<AdapterMessage<T>> {\n  return new Observable<AdapterMessage<T>>((subscriber) => {\n    let handle: SubscriptionHandle | null = null;\n    let cancelled = false;\n\n    pubsub\n      .subscribe<T>(\n        topic,\n        (msg) => {\n          subscriber.next(msg);\n        },\n        meta as never,\n      )\n      .then((h) => {\n        if (cancelled) {\n          void h.unsubscribe();\n        } else {\n          handle = h;\n        }\n      })\n      .catch((err) => {\n        if (!cancelled) subscriber.error(err);\n      });\n\n    return () => {\n      cancelled = true;\n      if (handle) {\n        void handle.unsubscribe();\n        handle = null;\n      }\n    };\n  });\n}\n\n/**\n * Same as `toObservable` but emits the unwrapped payload instead of the full\n * `AdapterMessage`. The convenience choice for app code that doesn't care\n * about topic / ack / raw envelope.\n */\nexport function fromTopic<T = unknown>(\n  pubsub: PubSub,\n  topic: string,\n  meta?: unknown,\n): Observable<T> {\n  return new Observable<T>((subscriber) => {\n    let handle: SubscriptionHandle | null = null;\n    let cancelled = false;\n\n    pubsub\n      .subscribe<T>(\n        topic,\n        (msg) => {\n          subscriber.next(msg.payload);\n        },\n        meta as never,\n      )\n      .then((h) => {\n        if (cancelled) {\n          void h.unsubscribe();\n        } else {\n          handle = h;\n        }\n      })\n      .catch((err) => {\n        if (!cancelled) subscriber.error(err);\n      });\n\n    return () => {\n      cancelled = true;\n      if (handle) {\n        void handle.unsubscribe();\n        handle = null;\n      }\n    };\n  });\n}\n"]}

package/dist/index.d.cts

@@ -0,0 +1,19 @@
+import { PubSub, AdapterMessage } from '@pubber-subber/core';
+import { Observable } from 'rxjs';
+
+/**
+ * Bridge a topic to an RxJS Observable that emits the full `AdapterMessage`.
+ *
+ * The subscription is created lazily when the first RxJS subscriber attaches,
+ * and torn down on unsubscribe. Handles the case where teardown races the
+ * underlying `pubsub.subscribe` resolution.
+ */
+declare function toObservable<T = unknown>(pubsub: PubSub, topic: string, meta?: unknown): Observable<AdapterMessage<T>>;
+/**
+ * Same as `toObservable` but emits the unwrapped payload instead of the full
+ * `AdapterMessage`. The convenience choice for app code that doesn't care
+ * about topic / ack / raw envelope.
+ */
+declare function fromTopic<T = unknown>(pubsub: PubSub, topic: string, meta?: unknown): Observable<T>;
+
+export { fromTopic, toObservable };

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+import { PubSub, AdapterMessage } from '@pubber-subber/core';
+import { Observable } from 'rxjs';
+
+/**
+ * Bridge a topic to an RxJS Observable that emits the full `AdapterMessage`.
+ *
+ * The subscription is created lazily when the first RxJS subscriber attaches,
+ * and torn down on unsubscribe. Handles the case where teardown races the
+ * underlying `pubsub.subscribe` resolution.
+ */
+declare function toObservable<T = unknown>(pubsub: PubSub, topic: string, meta?: unknown): Observable<AdapterMessage<T>>;
+/**
+ * Same as `toObservable` but emits the unwrapped payload instead of the full
+ * `AdapterMessage`. The convenience choice for app code that doesn't care
+ * about topic / ack / raw envelope.
+ */
+declare function fromTopic<T = unknown>(pubsub: PubSub, topic: string, meta?: unknown): Observable<T>;
+
+export { fromTopic, toObservable };

package/dist/index.js

@@ -0,0 +1,63 @@
+import { Observable } from 'rxjs';
+
+// src/index.ts
+function toObservable(pubsub, topic, meta) {
+  return new Observable((subscriber) => {
+    let handle = null;
+    let cancelled = false;
+    pubsub.subscribe(
+      topic,
+      (msg) => {
+        subscriber.next(msg);
+      },
+      meta
+    ).then((h) => {
+      if (cancelled) {
+        void h.unsubscribe();
+      } else {
+        handle = h;
+      }
+    }).catch((err) => {
+      if (!cancelled) subscriber.error(err);
+    });
+    return () => {
+      cancelled = true;
+      if (handle) {
+        void handle.unsubscribe();
+        handle = null;
+      }
+    };
+  });
+}
+function fromTopic(pubsub, topic, meta) {
+  return new Observable((subscriber) => {
+    let handle = null;
+    let cancelled = false;
+    pubsub.subscribe(
+      topic,
+      (msg) => {
+        subscriber.next(msg.payload);
+      },
+      meta
+    ).then((h) => {
+      if (cancelled) {
+        void h.unsubscribe();
+      } else {
+        handle = h;
+      }
+    }).catch((err) => {
+      if (!cancelled) subscriber.error(err);
+    });
+    return () => {
+      cancelled = true;
+      if (handle) {
+        void handle.unsubscribe();
+        handle = null;
+      }
+    };
+  });
+}
+
+export { fromTopic, toObservable };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"names":[],"mappings":";;;AAUO,SAAS,YAAA,CACd,MAAA,EACA,KAAA,EACA,IAAA,EAC+B;AAC/B,EAAA,OAAO,IAAI,UAAA,CAA8B,CAAC,UAAA,KAAe;AACvD,IAAA,IAAI,MAAA,GAAoC,IAAA;AACxC,IAAA,IAAI,SAAA,GAAY,KAAA;AAEhB,IAAA,MAAA,CACG,SAAA;AAAA,MACC,KAAA;AAAA,MACA,CAAC,GAAA,KAAQ;AACP,QAAA,UAAA,CAAW,KAAK,GAAG,CAAA;AAAA,MACrB,CAAA;AAAA,MACA;AAAA,KACF,CACC,IAAA,CAAK,CAAC,CAAA,KAAM;AACX,MAAA,IAAI,SAAA,EAAW;AACb,QAAA,KAAK,EAAE,WAAA,EAAY;AAAA,MACrB,CAAA,MAAO;AACL,QAAA,MAAA,GAAS,CAAA;AAAA,MACX;AAAA,IACF,CAAC,CAAA,CACA,KAAA,CAAM,CAAC,GAAA,KAAQ;AACd,MAAA,IAAI,CAAC,SAAA,EAAW,UAAA,CAAW,KAAA,CAAM,GAAG,CAAA;AAAA,IACtC,CAAC,CAAA;AAEH,IAAA,OAAO,MAAM;AACX,MAAA,SAAA,GAAY,IAAA;AACZ,MAAA,IAAI,MAAA,EAAQ;AACV,QAAA,KAAK,OAAO,WAAA,EAAY;AACxB,QAAA,MAAA,GAAS,IAAA;AAAA,MACX;AAAA,IACF,CAAA;AAAA,EACF,CAAC,CAAA;AACH;AAOO,SAAS,SAAA,CACd,MAAA,EACA,KAAA,EACA,IAAA,EACe;AACf,EAAA,OAAO,IAAI,UAAA,CAAc,CAAC,UAAA,KAAe;AACvC,IAAA,IAAI,MAAA,GAAoC,IAAA;AACxC,IAAA,IAAI,SAAA,GAAY,KAAA;AAEhB,IAAA,MAAA,CACG,SAAA;AAAA,MACC,KAAA;AAAA,MACA,CAAC,GAAA,KAAQ;AACP,QAAA,UAAA,CAAW,IAAA,CAAK,IAAI,OAAO,CAAA;AAAA,MAC7B,CAAA;AAAA,MACA;AAAA,KACF,CACC,IAAA,CAAK,CAAC,CAAA,KAAM;AACX,MAAA,IAAI,SAAA,EAAW;AACb,QAAA,KAAK,EAAE,WAAA,EAAY;AAAA,MACrB,CAAA,MAAO;AACL,QAAA,MAAA,GAAS,CAAA;AAAA,MACX;AAAA,IACF,CAAC,CAAA,CACA,KAAA,CAAM,CAAC,GAAA,KAAQ;AACd,MAAA,IAAI,CAAC,SAAA,EAAW,UAAA,CAAW,KAAA,CAAM,GAAG,CAAA;AAAA,IACtC,CAAC,CAAA;AAEH,IAAA,OAAO,MAAM;AACX,MAAA,SAAA,GAAY,IAAA;AACZ,MAAA,IAAI,MAAA,EAAQ;AACV,QAAA,KAAK,OAAO,WAAA,EAAY;AACxB,QAAA,MAAA,GAAS,IAAA;AAAA,MACX;AAAA,IACF,CAAA;AAAA,EACF,CAAC,CAAA;AACH","file":"index.js","sourcesContent":["import type { AdapterMessage, PubSub, SubscriptionHandle } from '@pubber-subber/core';\nimport { Observable } from 'rxjs';\n\n/**\n * Bridge a topic to an RxJS Observable that emits the full `AdapterMessage`.\n *\n * The subscription is created lazily when the first RxJS subscriber attaches,\n * and torn down on unsubscribe. Handles the case where teardown races the\n * underlying `pubsub.subscribe` resolution.\n */\nexport function toObservable<T = unknown>(\n  pubsub: PubSub,\n  topic: string,\n  meta?: unknown,\n): Observable<AdapterMessage<T>> {\n  return new Observable<AdapterMessage<T>>((subscriber) => {\n    let handle: SubscriptionHandle | null = null;\n    let cancelled = false;\n\n    pubsub\n      .subscribe<T>(\n        topic,\n        (msg) => {\n          subscriber.next(msg);\n        },\n        meta as never,\n      )\n      .then((h) => {\n        if (cancelled) {\n          void h.unsubscribe();\n        } else {\n          handle = h;\n        }\n      })\n      .catch((err) => {\n        if (!cancelled) subscriber.error(err);\n      });\n\n    return () => {\n      cancelled = true;\n      if (handle) {\n        void handle.unsubscribe();\n        handle = null;\n      }\n    };\n  });\n}\n\n/**\n * Same as `toObservable` but emits the unwrapped payload instead of the full\n * `AdapterMessage`. The convenience choice for app code that doesn't care\n * about topic / ack / raw envelope.\n */\nexport function fromTopic<T = unknown>(\n  pubsub: PubSub,\n  topic: string,\n  meta?: unknown,\n): Observable<T> {\n  return new Observable<T>((subscriber) => {\n    let handle: SubscriptionHandle | null = null;\n    let cancelled = false;\n\n    pubsub\n      .subscribe<T>(\n        topic,\n        (msg) => {\n          subscriber.next(msg.payload);\n        },\n        meta as never,\n      )\n      .then((h) => {\n        if (cancelled) {\n          void h.unsubscribe();\n        } else {\n          handle = h;\n        }\n      })\n      .catch((err) => {\n        if (!cancelled) subscriber.error(err);\n      });\n\n    return () => {\n      cancelled = true;\n      if (handle) {\n        void handle.unsubscribe();\n        handle = null;\n      }\n    };\n  });\n}\n"]}

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@pubber-subber/rxjs",
+  "version": "0.0.1",
+  "description": "RxJS bridge for @pubber-subber. Turn any topic subscription into an Observable.",
+  "keywords": [
+    "pubsub",
+    "pub-sub",
+    "messaging",
+    "events",
+    "rxjs",
+    "observable",
+    "reactive",
+    "typescript"
+  ],
+  "homepage": "https://github.com/samishal1998/pubber-subber/tree/main/packages/rxjs#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/samishal1998/pubber-subber.git",
+    "directory": "packages/rxjs"
+  },
+  "bugs": {
+    "url": "https://github.com/samishal1998/pubber-subber/issues"
+  },
+  "author": "Sami Mishal",
+  "type": "module",
+  "license": "MIT",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": ["dist", "src", "README.md", "LICENSE"],
+  "scripts": {
+    "prebuild": "node ../../scripts/swap-package-json.mjs build",
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "node ../../scripts/swap-package-json.mjs publish",
+    "postpublish": "node ../../scripts/swap-package-json.mjs build"
+  },
+  "peerDependencies": {
+    "@pubber-subber/core": "^0.0.1",
+    "rxjs": "^7.0.0 || ^8.0.0"
+  },
+  "devDependencies": {
+    "@pubber-subber/core": "workspace:*",
+    "@pubber-subber/memory": "workspace:*",
+    "rxjs": "^7.8.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/index.ts

@@ -0,0 +1,90 @@
+import type { AdapterMessage, PubSub, SubscriptionHandle } from '@pubber-subber/core';
+import { Observable } from 'rxjs';
+
+/**
+ * Bridge a topic to an RxJS Observable that emits the full `AdapterMessage`.
+ *
+ * The subscription is created lazily when the first RxJS subscriber attaches,
+ * and torn down on unsubscribe. Handles the case where teardown races the
+ * underlying `pubsub.subscribe` resolution.
+ */
+export function toObservable<T = unknown>(
+  pubsub: PubSub,
+  topic: string,
+  meta?: unknown,
+): Observable<AdapterMessage<T>> {
+  return new Observable<AdapterMessage<T>>((subscriber) => {
+    let handle: SubscriptionHandle | null = null;
+    let cancelled = false;
+
+    pubsub
+      .subscribe<T>(
+        topic,
+        (msg) => {
+          subscriber.next(msg);
+        },
+        meta as never,
+      )
+      .then((h) => {
+        if (cancelled) {
+          void h.unsubscribe();
+        } else {
+          handle = h;
+        }
+      })
+      .catch((err) => {
+        if (!cancelled) subscriber.error(err);
+      });
+
+    return () => {
+      cancelled = true;
+      if (handle) {
+        void handle.unsubscribe();
+        handle = null;
+      }
+    };
+  });
+}
+
+/**
+ * Same as `toObservable` but emits the unwrapped payload instead of the full
+ * `AdapterMessage`. The convenience choice for app code that doesn't care
+ * about topic / ack / raw envelope.
+ */
+export function fromTopic<T = unknown>(
+  pubsub: PubSub,
+  topic: string,
+  meta?: unknown,
+): Observable<T> {
+  return new Observable<T>((subscriber) => {
+    let handle: SubscriptionHandle | null = null;
+    let cancelled = false;
+
+    pubsub
+      .subscribe<T>(
+        topic,
+        (msg) => {
+          subscriber.next(msg.payload);
+        },
+        meta as never,
+      )
+      .then((h) => {
+        if (cancelled) {
+          void h.unsubscribe();
+        } else {
+          handle = h;
+        }
+      })
+      .catch((err) => {
+        if (!cancelled) subscriber.error(err);
+      });
+
+    return () => {
+      cancelled = true;
+      if (handle) {
+        void handle.unsubscribe();
+        handle = null;
+      }
+    };
+  });
+}