@voyant-travel/realtime 0.1.0

package/README.md

@@ -0,0 +1,138 @@
+# @voyant-travel/realtime
+
+Provider-agnostic realtime channels for Voyant deployments. Push live updates to
+admin and customer-facing UIs instead of polling — without coupling the
+framework to any single transport vendor.
+
+Implements [RFC #1695](https://github.com/voyant-travel/voyant/issues/1695).
+
+## What's in the box
+
+- **`RealtimeProvider`** — the transport interface. Voyant Cloud is one
+  implementation; any pub/sub backend (Ably, Pusher, Centrifugo, a self-hosted
+  WebSocket/SSE service, …) can satisfy it.
+- **EventBus bridge** (`createRealtimeBridge`) — deferred, outbox-safe
+  subscribers that fan domain events out to channels as **invalidation hints**.
+- **Token-mint route** (`createRealtimeRoutes`) — issues short-lived,
+  capability-scoped client tokens from the caller's session. Browsers never see
+  API keys.
+- **`createRealtimeHonoModule`** — wires all of the above into a `HonoModule`.
+
+The module owns no schema and is **fully optional**: with no provider
+configured, the token route returns `503` and no subscribers register.
+
+## The provider interface (bring your own vendor)
+
+```ts
+interface RealtimeProvider {
+  readonly name: string
+  publish(channel: string, message: { event: string; data: unknown }): Promise<void>
+  mintClientToken(input: {
+    clientId: string
+    capabilities: Record<string, ReadonlyArray<"subscribe" | "publish" | "presence">>
+    ttlSeconds?: number
+  }): Promise<{ token: string; expiresAt: string }>
+}
+```
+
+Built-in implementations:
+
+| Factory | Backend | Use |
+| --- | --- | --- |
+| `createLocalRealtimeProvider()` | in-memory | dev, tests, reference impl |
+| `createVoyantCloudRealtimeProvider({ client })` | Voyant Cloud | default cloud transport |
+
+### Implementing your own adapter
+
+`mintClientToken` is the abstraction line: every vendor mints tokens
+differently (Ably `TokenRequest`, Pusher auth signature, a self-hosted JWT), but
+the token-mint route never knows the vendor.
+
+```ts
+import type { RealtimeProvider } from "@voyant-travel/realtime/types"
+
+export function createMyVendorProvider(opts: MyVendorOptions): RealtimeProvider {
+  const client = new MyVendorSdk(opts)
+  return {
+    name: "my-vendor",
+    async publish(channel, message) {
+      await client.trigger(channel, message.event, message.data)
+    },
+    async mintClientToken({ clientId, capabilities, ttlSeconds }) {
+      const { token, exp } = await client.signToken({ clientId, capabilities, ttlSeconds })
+      return { token, expiresAt: new Date(exp * 1000).toISOString() }
+    },
+  }
+}
+```
+
+Pass it to `createRealtimeHonoModule({ providers: [createMyVendorProvider(...)] })`
+and the deployment is live on your backend — no framework changes.
+
+## Wiring it into an app
+
+```ts
+import { createRealtimeHonoModule } from "@voyant-travel/realtime"
+import { createVoyantCloudRealtimeProvider } from "@voyant-travel/realtime/providers/voyant-cloud"
+
+const realtime = createRealtimeHonoModule({
+  // Resolve the provider from runtime bindings (e.g. a Cloud client from env).
+  resolveProviders: (bindings) => [
+    createVoyantCloudRealtimeProvider({ client: getCloudClient(bindings) }),
+  ],
+
+  // Fan domain events out to channels. Payload is an invalidation hint.
+  bridgeRoutes: {
+    "booking.confirmed": (e) => ["admin", `booking:${e.bookingId}`],
+    "booking.fully-paid": (e) => ({
+      channels: ["admin", `booking:${e.bookingId}`],
+      hint: { entity: "booking", id: e.bookingId },
+    }),
+    "availability.slot.changed": (e) => ({
+      channels: ["admin", `product:${e.productId}`],
+      hint: { entity: "availability", id: e.productId },
+    }),
+  },
+
+  // Let portal customers subscribe to the bookings they own.
+  resolvePortalScope: async (c) => {
+    const personId = await lookupPersonId(c.get("db"), c.get("userId"))
+    if (!personId) return null
+    return { personId, bookingIds: await ownedBookingIds(c.get("db"), personId) }
+  },
+})
+
+// Register `realtime` like any other HonoModule. The token route mounts at
+// POST /v1/admin/realtime/token and POST /v1/public/realtime/token.
+```
+
+## Why invalidation hints, not entities
+
+The bridge's default payload is `{ event, entity, id }`, not the changed record.
+The React layer reacts by invalidating matching React Query keys and refetching
+over the existing authenticated HTTP path. This keeps HTTP the source of truth,
+makes at-most-once delivery acceptable (a missed hint self-heals on the next
+refetch/`staleTime` tick), and avoids leaking entity data through channel
+capabilities.
+
+Bridge subscribers are **deferred** (`inline: false`) — they run after the HTTP
+response via the runtime scheduler (`executionCtx.waitUntil` on Workers) and
+never block the emitting transaction. Publish failures are swallowed (routed to
+`onPublishError`), because a dropped hint is self-healing.
+
+> **Stronger guarantees?** If a channel ever needs at-least-once delivery, the
+> codebase's durable channel-push pattern (write an intent row in a deferred
+> subscriber → drain via a workflow) is the upgrade path. This module ships the
+> at-most-once tier by design.
+
+## Channel conventions
+
+| Channel | Audience | Capability granted by |
+| --- | --- | --- |
+| `admin` | all admin users of the deployment | admin session |
+| `booking:{bookingId}` | admins; the booking's customer | session + ownership |
+| `portal:customer:{personId}` | that customer in the portal | portal session |
+| `notifications:user:{userId}` | a specific staff user | admin session |
+
+See `@voyant-travel/realtime-react` for the `useChannel` / `usePresence` /
+`useLiveQueries` hooks that consume these channels.

package/dist/bridge.d.ts

@@ -0,0 +1,31 @@
+import type { Subscriber } from "@voyant-travel/core";
+import type { RealtimeProvider, RealtimeRoutes } from "./types.js";
+export interface CreateRealtimeBridgeOptions {
+    /** Transport to publish through. */
+    provider: RealtimeProvider;
+    /** Declarative event → channel routing table. */
+    routes: RealtimeRoutes;
+    /**
+     * Optional sink for publish failures. Defaults to `console.warn`. The bridge
+     * never throws: a dropped hint self-heals on the next refetch, so a transport
+     * blip must not break the emitting transaction.
+     */
+    onError?: (error: unknown, context: {
+        event: string;
+        channel: string;
+    }) => void;
+}
+/**
+ * Build the deferred {@link Subscriber}s that fan domain events out to realtime
+ * channels. The returned array plugs straight into `Plugin.subscribers` or a
+ * module's `bootstrap` via `eventBus.subscribe`.
+ *
+ * Subscribers are **deferred** (`inline: false`) — they run after the HTTP
+ * response via the runtime's scheduler (`executionCtx.waitUntil` on Workers),
+ * so they never block the emitting transaction. Delivery is best-effort and
+ * at-most-once by design; the published payload is an
+ * {@link RealtimeInvalidationHint}, so a missed message self-heals on the next
+ * client refetch.
+ */
+export declare function createRealtimeBridge(options: CreateRealtimeBridgeOptions): Subscriber[];
+//# sourceMappingURL=bridge.d.ts.map

package/dist/bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridge.d.ts","sourceRoot":"","sources":["../src/bridge.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAErD,OAAO,KAAK,EAEV,gBAAgB,EAGhB,cAAc,EACf,MAAM,YAAY,CAAA;AAEnB,MAAM,WAAW,2BAA2B;IAC1C,oCAAoC;IACpC,QAAQ,EAAE,gBAAgB,CAAA;IAC1B,iDAAiD;IACjD,MAAM,EAAE,cAAc,CAAA;IACtB;;;;OAIG;IACH,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAA;CAChF;AAcD;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,2BAA2B,GAAG,UAAU,EAAE,CAkCvF"}

package/dist/bridge.js

@@ -0,0 +1,46 @@
+function isRouteResult(value) {
+    return !Array.isArray(value);
+}
+/** Derive the entity family from an event name (`booking.confirmed` → `booking`). */
+function resourceOf(event) {
+    const dot = event.indexOf(".");
+    return dot === -1 ? event : event.slice(0, dot);
+}
+/**
+ * Build the deferred {@link Subscriber}s that fan domain events out to realtime
+ * channels. The returned array plugs straight into `Plugin.subscribers` or a
+ * module's `bootstrap` via `eventBus.subscribe`.
+ *
+ * Subscribers are **deferred** (`inline: false`) — they run after the HTTP
+ * response via the runtime's scheduler (`executionCtx.waitUntil` on Workers),
+ * so they never block the emitting transaction. Delivery is best-effort and
+ * at-most-once by design; the published payload is an
+ * {@link RealtimeInvalidationHint}, so a missed message self-heals on the next
+ * client refetch.
+ */
+export function createRealtimeBridge(options) {
+    const { provider, routes } = options;
+    const onError = options.onError ??
+        ((error, context) => {
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`[realtime] publish failed for ${context.event} → ${context.channel}: ${message}`);
+        });
+    return Object.entries(routes).map(([event, route]) => ({
+        event,
+        inline: false,
+        handler: async (envelope) => {
+            const result = route(envelope.data, envelope);
+            const channels = isRouteResult(result) ? result.channels : result;
+            if (channels.length === 0)
+                return;
+            const hint = {
+                event,
+                entity: resourceOf(event),
+                ...(isRouteResult(result) ? result.hint : undefined),
+            };
+            await Promise.all(channels.map((channel) => provider
+                .publish(channel, { event, data: hint })
+                .catch((error) => onError(error, { event, channel }))));
+        },
+    }));
+}

package/dist/capabilities.d.ts

@@ -0,0 +1,36 @@
+import type { Actor } from "@voyant-travel/core";
+import type { RealtimeCapabilities } from "./types.js";
+/**
+ * Portal ownership scope for a customer session — supplied by the deployment
+ * (which owns the CRM/bookings schemas), so this package stays decoupled from
+ * those modules.
+ */
+export interface PortalScope {
+    /** The CRM person id behind the portal session. */
+    personId: string;
+    /** Booking ids the customer may subscribe to. */
+    bookingIds: ReadonlyArray<string>;
+}
+export interface RealtimeCapabilityContext {
+    actor: Actor | undefined;
+    userId: string | undefined;
+    /** Resolved portal scope for customer/partner/supplier sessions. */
+    portalScope?: PortalScope | null;
+}
+/**
+ * Resolve the channel capabilities a session is entitled to, per the RFC's
+ * channel conventions:
+ *
+ * | Channel                        | Audience                              |
+ * | ------------------------------ | ------------------------------------- |
+ * | `admin`                        | all admin users of the deployment     |
+ * | `booking:{bookingId}`          | admins; the booking's customer        |
+ * | `portal:customer:{personId}`   | that customer in the portal           |
+ * | `notifications:user:{userId}`  | a specific staff user                 |
+ *
+ * Staff sessions get broad admin scope; portal sessions get only their own
+ * person channel and the bookings they own. Browsers never see API keys — only
+ * the short-lived scoped token minted from these capabilities.
+ */
+export declare function resolveRealtimeCapabilities(ctx: RealtimeCapabilityContext): RealtimeCapabilities;
+//# sourceMappingURL=capabilities.d.ts.map

package/dist/capabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../src/capabilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAA;AAEhD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAA;AAEtD;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,mDAAmD;IACnD,QAAQ,EAAE,MAAM,CAAA;IAChB,iDAAiD;IACjD,UAAU,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CAClC;AAED,MAAM,WAAW,yBAAyB;IACxC,KAAK,EAAE,KAAK,GAAG,SAAS,CAAA;IACxB,MAAM,EAAE,MAAM,GAAG,SAAS,CAAA;IAC1B,oEAAoE;IACpE,WAAW,CAAC,EAAE,WAAW,GAAG,IAAI,CAAA;CACjC;AAKD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,2BAA2B,CAAC,GAAG,EAAE,yBAAyB,GAAG,oBAAoB,CAwBhG"}

package/dist/capabilities.js

@@ -0,0 +1,39 @@
+const SUBSCRIBE = ["subscribe"];
+const SUBSCRIBE_PRESENCE = ["subscribe", "presence"];
+/**
+ * Resolve the channel capabilities a session is entitled to, per the RFC's
+ * channel conventions:
+ *
+ * | Channel                        | Audience                              |
+ * | ------------------------------ | ------------------------------------- |
+ * | `admin`                        | all admin users of the deployment     |
+ * | `booking:{bookingId}`          | admins; the booking's customer        |
+ * | `portal:customer:{personId}`   | that customer in the portal           |
+ * | `notifications:user:{userId}`  | a specific staff user                 |
+ *
+ * Staff sessions get broad admin scope; portal sessions get only their own
+ * person channel and the bookings they own. Browsers never see API keys — only
+ * the short-lived scoped token minted from these capabilities.
+ */
+export function resolveRealtimeCapabilities(ctx) {
+    const capabilities = {};
+    if (!ctx.userId || !ctx.actor) {
+        return capabilities;
+    }
+    if (ctx.actor === "staff") {
+        capabilities.admin = SUBSCRIBE;
+        // Wildcard subscribe — admins may watch any booking detail screen.
+        capabilities["booking:*"] = SUBSCRIBE;
+        capabilities[`notifications:user:${ctx.userId}`] = SUBSCRIBE_PRESENCE;
+        return capabilities;
+    }
+    // Customer / partner / supplier (portal) sessions.
+    capabilities[`notifications:user:${ctx.userId}`] = SUBSCRIBE;
+    if (ctx.portalScope) {
+        capabilities[`portal:customer:${ctx.portalScope.personId}`] = SUBSCRIBE_PRESENCE;
+        for (const bookingId of ctx.portalScope.bookingIds) {
+            capabilities[`booking:${bookingId}`] = SUBSCRIBE;
+        }
+    }
+    return capabilities;
+}

package/dist/index.d.ts

@@ -0,0 +1,43 @@
+import type { Module } from "@voyant-travel/core";
+import type { HonoModule } from "@voyant-travel/hono/module";
+import { type RealtimeRoutesOptions } from "./routes.js";
+import type { RealtimeRoutes } from "./types.js";
+export type { CreateRealtimeBridgeOptions } from "./bridge.js";
+export { createRealtimeBridge } from "./bridge.js";
+export type { PortalScope, RealtimeCapabilityContext, } from "./capabilities.js";
+export { resolveRealtimeCapabilities } from "./capabilities.js";
+export type { LocalRealtimeListener, LocalRealtimeProvider, LocalRealtimeProviderOptions, } from "./providers/local.js";
+export { createLocalRealtimeProvider } from "./providers/local.js";
+export type { RealtimeCloudClient, RealtimeCloudNamespace, VoyantCloudRealtimeProviderOptions, } from "./providers/voyant-cloud.js";
+export { createVoyantCloudRealtimeProvider } from "./providers/voyant-cloud.js";
+export type { RealtimeRouteRuntime, RealtimeRoutesOptions, ResolvePortalScope, } from "./routes.js";
+export { buildRealtimeRouteRuntime, createRealtimeRoutes, REALTIME_ROUTE_RUNTIME_CONTAINER_KEY, } from "./routes.js";
+export type { RealtimeService } from "./service.js";
+export { createRealtimeService, RealtimeError } from "./service.js";
+export type { MintClientTokenInput, MintedClientToken, RealtimeCapabilities, RealtimeCapability, RealtimeInvalidationHint, RealtimeMessage, RealtimeProvider, RealtimeRoute, RealtimeRouteResult, RealtimeRoutes, } from "./types.js";
+/** Core module identity. The realtime module owns no schema — it is stateless. */
+export declare const realtimeModule: Module;
+export interface CreateRealtimeHonoModuleOptions extends RealtimeRoutesOptions {
+    /**
+     * Declarative event → channel routing table. When set, deferred EventBus
+     * subscribers are registered at bootstrap to fan domain events out to
+     * realtime channels as invalidation hints.
+     */
+    bridgeRoutes?: RealtimeRoutes;
+    /** Optional sink for bridge publish failures (defaults to `console.warn`). */
+    onPublishError?: (error: unknown, context: {
+        event: string;
+        channel: string;
+    }) => void;
+}
+/**
+ * Assemble the realtime {@link HonoModule}: the token-mint route (mounted on
+ * both admin and public surfaces) plus, when `bridgeRoutes` is supplied, the
+ * deferred EventBus → channel bridge.
+ *
+ * The module is fully optional: with no providers configured the token route
+ * returns 503 and no subscribers are registered, so deployments can adopt
+ * realtime incrementally (or never).
+ */
+export declare function createRealtimeHonoModule(options?: CreateRealtimeHonoModuleOptions): HonoModule;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AACjD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAA;AAG5D,OAAO,EAIL,KAAK,qBAAqB,EAC3B,MAAM,aAAa,CAAA;AACpB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAEhD,YAAY,EAAE,2BAA2B,EAAE,MAAM,aAAa,CAAA;AAC9D,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAA;AAClD,YAAY,EACV,WAAW,EACX,yBAAyB,GAC1B,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EAAE,2BAA2B,EAAE,MAAM,mBAAmB,CAAA;AAC/D,YAAY,EACV,qBAAqB,EACrB,qBAAqB,EACrB,4BAA4B,GAC7B,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAAE,2BAA2B,EAAE,MAAM,sBAAsB,CAAA;AAClE,YAAY,EACV,mBAAmB,EACnB,sBAAsB,EACtB,kCAAkC,GACnC,MAAM,6BAA6B,CAAA;AACpC,OAAO,EAAE,iCAAiC,EAAE,MAAM,6BAA6B,CAAA;AAC/E,YAAY,EACV,oBAAoB,EACpB,qBAAqB,EACrB,kBAAkB,GACnB,MAAM,aAAa,CAAA;AACpB,OAAO,EACL,yBAAyB,EACzB,oBAAoB,EACpB,oCAAoC,GACrC,MAAM,aAAa,CAAA;AACpB,YAAY,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AACnD,OAAO,EAAE,qBAAqB,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AACnE,YAAY,EACV,oBAAoB,EACpB,iBAAiB,EACjB,oBAAoB,EACpB,kBAAkB,EAClB,wBAAwB,EACxB,eAAe,EACf,gBAAgB,EAChB,aAAa,EACb,mBAAmB,EACnB,cAAc,GACf,MAAM,YAAY,CAAA;AAEnB,kFAAkF;AAClF,eAAO,MAAM,cAAc,EAAE,MAE5B,CAAA;AAED,MAAM,WAAW,+BAAgC,SAAQ,qBAAqB;IAC5E;;;;OAIG;IACH,YAAY,CAAC,EAAE,cAAc,CAAA;IAC7B,8EAA8E;IAC9E,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAA;CACvF;AAED;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,GAAE,+BAAoC,GAC5C,UAAU,CA8BZ"}

package/dist/index.js

@@ -0,0 +1,49 @@
+import { createRealtimeBridge } from "./bridge.js";
+import { buildRealtimeRouteRuntime, createRealtimeRoutes, REALTIME_ROUTE_RUNTIME_CONTAINER_KEY, } from "./routes.js";
+export { createRealtimeBridge } from "./bridge.js";
+export { resolveRealtimeCapabilities } from "./capabilities.js";
+export { createLocalRealtimeProvider } from "./providers/local.js";
+export { createVoyantCloudRealtimeProvider } from "./providers/voyant-cloud.js";
+export { buildRealtimeRouteRuntime, createRealtimeRoutes, REALTIME_ROUTE_RUNTIME_CONTAINER_KEY, } from "./routes.js";
+export { createRealtimeService, RealtimeError } from "./service.js";
+/** Core module identity. The realtime module owns no schema — it is stateless. */
+export const realtimeModule = {
+    name: "realtime",
+};
+/**
+ * Assemble the realtime {@link HonoModule}: the token-mint route (mounted on
+ * both admin and public surfaces) plus, when `bridgeRoutes` is supplied, the
+ * deferred EventBus → channel bridge.
+ *
+ * The module is fully optional: with no providers configured the token route
+ * returns 503 and no subscribers are registered, so deployments can adopt
+ * realtime incrementally (or never).
+ */
+export function createRealtimeHonoModule(options = {}) {
+    const routes = createRealtimeRoutes(options);
+    const module = {
+        ...realtimeModule,
+        bootstrap: ({ bindings, container, eventBus }) => {
+            const runtime = buildRealtimeRouteRuntime(bindings, options);
+            container.register(REALTIME_ROUTE_RUNTIME_CONTAINER_KEY, runtime);
+            // No provider configured → nothing to publish to; stay inert.
+            if (runtime.service && options.bridgeRoutes && Object.keys(options.bridgeRoutes).length > 0) {
+                const subscribers = createRealtimeBridge({
+                    provider: runtime.service.defaultProvider,
+                    routes: options.bridgeRoutes,
+                    onError: options.onPublishError,
+                });
+                for (const subscriber of subscribers) {
+                    eventBus.subscribe(subscriber.event, subscriber.handler, {
+                        inline: subscriber.inline ?? false,
+                    });
+                }
+            }
+        },
+    };
+    return {
+        module,
+        adminRoutes: routes,
+        publicRoutes: routes,
+    };
+}

package/dist/providers/local.d.ts

@@ -0,0 +1,24 @@
+import type { RealtimeMessage, RealtimeProvider } from "../types.js";
+export type LocalRealtimeListener = (message: RealtimeMessage) => void;
+export interface LocalRealtimeProviderOptions {
+    /** Provider name (defaults to `"local"`). */
+    name?: string;
+    /**
+     * Optional sink for every published message (across all channels). Defaults
+     * to `console.log`. Tests can pass a `vi.fn()` to capture publishes.
+     */
+    sink?: (channel: string, message: RealtimeMessage) => void;
+    /** Default token lifetime in seconds (defaults to 3600). */
+    defaultTtlSeconds?: number;
+}
+/**
+ * In-memory realtime provider for development, tests, and as the reference
+ * implementation. Supports per-channel subscription so an in-process consumer
+ * (or a test) can observe fan-out without a network transport.
+ */
+export interface LocalRealtimeProvider extends RealtimeProvider {
+    /** Subscribe an in-process listener to a channel. Returns an unsubscribe fn. */
+    subscribe(channel: string, listener: LocalRealtimeListener): () => void;
+}
+export declare function createLocalRealtimeProvider(options?: LocalRealtimeProviderOptions): LocalRealtimeProvider;
+//# sourceMappingURL=local.d.ts.map

package/dist/providers/local.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local.d.ts","sourceRoot":"","sources":["../../src/providers/local.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,eAAe,EACf,gBAAgB,EACjB,MAAM,aAAa,CAAA;AAEpB,MAAM,MAAM,qBAAqB,GAAG,CAAC,OAAO,EAAE,eAAe,KAAK,IAAI,CAAA;AAEtE,MAAM,WAAW,4BAA4B;IAC3C,6CAA6C;IAC7C,IAAI,CAAC,EAAE,MAAM,CAAA;IACb;;;OAGG;IACH,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,KAAK,IAAI,CAAA;IAC1D,4DAA4D;IAC5D,iBAAiB,CAAC,EAAE,MAAM,CAAA;CAC3B;AAED;;;;GAIG;AACH,MAAM,WAAW,qBAAsB,SAAQ,gBAAgB;IAC7D,gFAAgF;IAChF,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,qBAAqB,GAAG,MAAM,IAAI,CAAA;CACxE;AAED,wBAAgB,2BAA2B,CACzC,OAAO,GAAE,4BAAiC,GACzC,qBAAqB,CA8CvB"}

package/dist/providers/local.js

@@ -0,0 +1,44 @@
+export function createLocalRealtimeProvider(options = {}) {
+    const name = options.name ?? "local";
+    const defaultTtlSeconds = options.defaultTtlSeconds ?? 3600;
+    const sink = options.sink ??
+        ((channel, message) => {
+            console.log(`[realtime:${name}] ${channel}`, message);
+        });
+    const listeners = new Map();
+    let tokenCounter = 0;
+    return {
+        name,
+        async publish(channel, message) {
+            sink(channel, message);
+            const channelListeners = listeners.get(channel);
+            if (channelListeners) {
+                for (const listener of channelListeners) {
+                    listener(message);
+                }
+            }
+        },
+        async mintClientToken(input) {
+            tokenCounter += 1;
+            const ttl = input.ttlSeconds ?? defaultTtlSeconds;
+            // Opaque, non-cryptographic token — local provider never authenticates a
+            // real transport. The capability set is embedded for inspectability.
+            const token = `${name}_${tokenCounter}.${input.clientId}`;
+            return {
+                token,
+                expiresAt: new Date(Date.now() + ttl * 1000).toISOString(),
+            };
+        },
+        subscribe(channel, listener) {
+            let set = listeners.get(channel);
+            if (!set) {
+                set = new Set();
+                listeners.set(channel, set);
+            }
+            set.add(listener);
+            return () => {
+                set?.delete(listener);
+            };
+        },
+    };
+}

package/dist/providers/voyant-cloud.d.ts

@@ -0,0 +1,39 @@
+import type { MintClientTokenInput, MintedClientToken, RealtimeProvider } from "../types.js";
+/**
+ * The subset of the Cloud SDK `realtime` namespace this provider uses —
+ * `publish(channel, { event, data })` and `tokens.mint(input)`. Declared
+ * structurally (rather than importing `VoyantCloudClient`) to keep this package
+ * free of a hard `@voyant-travel/cloud-sdk` dependency; the real
+ * `getVoyantCloudClient(env)` satisfies it directly, so deployments pass the SDK
+ * client with no cast.
+ *
+ * @see https://github.com/voyant-travel/voyant/issues/1695
+ */
+export interface RealtimeCloudNamespace {
+    publish(channel: string, input: {
+        event: string;
+        data?: unknown;
+    }): Promise<unknown>;
+    tokens: {
+        mint(input: MintClientTokenInput): Promise<MintedClientToken>;
+    };
+}
+export interface RealtimeCloudClient {
+    realtime: RealtimeCloudNamespace;
+}
+export interface VoyantCloudRealtimeProviderOptions {
+    /**
+     * Cloud SDK client. Construct via `getVoyantCloudClient(env)` and pass it
+     * here; this provider only touches its `realtime` namespace.
+     */
+    client: RealtimeCloudClient;
+    /** Provider name override (defaults to `"voyant-cloud"`). */
+    name?: string;
+}
+/**
+ * Realtime provider backed by Voyant Cloud. All transport, auth, and error
+ * handling come from the SDK — no hand-rolled fetch — exactly like
+ * `createVoyantCloudEmailProvider`.
+ */
+export declare function createVoyantCloudRealtimeProvider(options: VoyantCloudRealtimeProviderOptions): RealtimeProvider;
+//# sourceMappingURL=voyant-cloud.d.ts.map

package/dist/providers/voyant-cloud.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"voyant-cloud.d.ts","sourceRoot":"","sources":["../../src/providers/voyant-cloud.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,oBAAoB,EACpB,iBAAiB,EAEjB,gBAAgB,EACjB,MAAM,aAAa,CAAA;AAEpB;;;;;;;;;GASG;AACH,MAAM,WAAW,sBAAsB;IACrC,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IACpF,MAAM,EAAE;QACN,IAAI,CAAC,KAAK,EAAE,oBAAoB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAA;KAC9D,CAAA;CACF;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,sBAAsB,CAAA;CACjC;AAED,MAAM,WAAW,kCAAkC;IACjD;;;OAGG;IACH,MAAM,EAAE,mBAAmB,CAAA;IAC3B,6DAA6D;IAC7D,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED;;;;GAIG;AACH,wBAAgB,iCAAiC,CAC/C,OAAO,EAAE,kCAAkC,GAC1C,gBAAgB,CAclB"}

package/dist/providers/voyant-cloud.js

@@ -0,0 +1,20 @@
+/**
+ * Realtime provider backed by Voyant Cloud. All transport, auth, and error
+ * handling come from the SDK — no hand-rolled fetch — exactly like
+ * `createVoyantCloudEmailProvider`.
+ */
+export function createVoyantCloudRealtimeProvider(options) {
+    const name = options.name ?? "voyant-cloud";
+    return {
+        name,
+        async publish(channel, message) {
+            await options.client.realtime.publish(channel, {
+                event: message.event,
+                data: message.data,
+            });
+        },
+        mintClientToken(input) {
+            return options.client.realtime.tokens.mint(input);
+        },
+    };
+}

package/dist/routes.d.ts

@@ -0,0 +1,48 @@
+import type { Actor, ModuleContainer } from "@voyant-travel/core";
+import type { Context } from "hono";
+import { Hono } from "hono";
+import { type PortalScope } from "./capabilities.js";
+import { type RealtimeService } from "./service.js";
+import type { RealtimeProvider } from "./types.js";
+export declare const REALTIME_ROUTE_RUNTIME_CONTAINER_KEY = "providers.realtime.runtime";
+type Env = {
+    Bindings: Record<string, unknown>;
+    Variables: {
+        container: ModuleContainer;
+        actor?: Actor;
+        userId?: string;
+    };
+};
+/** Resolves the portal ownership scope for a non-staff session. */
+export type ResolvePortalScope = (c: Context<Env>) => Promise<PortalScope | null> | PortalScope | null;
+export interface RealtimeRoutesOptions {
+    /** Transport(s) used to mint client tokens. First is the default. */
+    providers?: ReadonlyArray<RealtimeProvider>;
+    /** Resolve providers from runtime bindings (e.g. a Cloud client from env). */
+    resolveProviders?: (bindings: Record<string, unknown>) => ReadonlyArray<RealtimeProvider>;
+    /**
+     * Resolve the bookings/person a portal session owns. Required for customers
+     * to receive `portal:customer:*` / `booking:*` capabilities; without it they
+     * only get their personal `notifications:user:*` channel.
+     */
+    resolvePortalScope?: ResolvePortalScope;
+    /** Default token lifetime in seconds. */
+    defaultTtlSeconds?: number;
+}
+export interface RealtimeRouteRuntime {
+    /** Null when no provider is configured — the module stays inert/optional. */
+    service: RealtimeService | null;
+    resolvePortalScope?: ResolvePortalScope;
+    defaultTtlSeconds?: number;
+}
+export declare function buildRealtimeRouteRuntime(bindings: Record<string, unknown>, options?: RealtimeRoutesOptions): RealtimeRouteRuntime;
+/**
+ * Routes that mint short-lived, capability-scoped client tokens from the
+ * caller's session. Mounted as both `adminRoutes` and `publicRoutes`: the app's
+ * actor guards ensure `/v1/admin/*` carries a staff actor and `/v1/public/*` a
+ * customer/partner/supplier actor, and {@link resolveRealtimeCapabilities}
+ * scopes the token accordingly.
+ */
+export declare function createRealtimeRoutes(options?: RealtimeRoutesOptions): Hono<Env>;
+export {};
+//# sourceMappingURL=routes.d.ts.map

package/dist/routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../src/routes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AACjE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AACnC,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAA;AAE3B,OAAO,EACL,KAAK,WAAW,EAGjB,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EAAyB,KAAK,eAAe,EAAE,MAAM,cAAc,CAAA;AAC1E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAElD,eAAO,MAAM,oCAAoC,+BAA+B,CAAA;AAEhF,KAAK,GAAG,GAAG;IACT,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACjC,SAAS,EAAE;QACT,SAAS,EAAE,eAAe,CAAA;QAC1B,KAAK,CAAC,EAAE,KAAK,CAAA;QACb,MAAM,CAAC,EAAE,MAAM,CAAA;KAChB,CAAA;CACF,CAAA;AAED,mEAAmE;AACnE,MAAM,MAAM,kBAAkB,GAAG,CAC/B,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,KACZ,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,GAAG,WAAW,GAAG,IAAI,CAAA;AAErD,MAAM,WAAW,qBAAqB;IACpC,qEAAqE;IACrE,SAAS,CAAC,EAAE,aAAa,CAAC,gBAAgB,CAAC,CAAA;IAC3C,8EAA8E;IAC9E,gBAAgB,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,aAAa,CAAC,gBAAgB,CAAC,CAAA;IACzF;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,kBAAkB,CAAA;IACvC,yCAAyC;IACzC,iBAAiB,CAAC,EAAE,MAAM,CAAA;CAC3B;AAED,MAAM,WAAW,oBAAoB;IACnC,6EAA6E;IAC7E,OAAO,EAAE,eAAe,GAAG,IAAI,CAAA;IAC/B,kBAAkB,CAAC,EAAE,kBAAkB,CAAA;IACvC,iBAAiB,CAAC,EAAE,MAAM,CAAA;CAC3B;AAED,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,OAAO,GAAE,qBAA0B,GAClC,oBAAoB,CAWtB;AAUD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,GAAE,qBAA0B,GAAG,IAAI,CAAC,GAAG,CAAC,CA0CnF"}

package/dist/routes.js

@@ -0,0 +1,65 @@
+import { Hono } from "hono";
+import { resolveRealtimeCapabilities, } from "./capabilities.js";
+import { createRealtimeService } from "./service.js";
+export const REALTIME_ROUTE_RUNTIME_CONTAINER_KEY = "providers.realtime.runtime";
+export function buildRealtimeRouteRuntime(bindings, options = {}) {
+    const providers = options.resolveProviders
+        ? options.resolveProviders(bindings)
+        : (options.providers ?? []);
+    return {
+        // Tolerate zero providers (e.g. no API key configured): the token route
+        // 503s and the bridge registers nothing, rather than failing app boot.
+        service: providers.length > 0 ? createRealtimeService(providers) : null,
+        resolvePortalScope: options.resolvePortalScope,
+        defaultTtlSeconds: options.defaultTtlSeconds,
+    };
+}
+function getRuntime(c) {
+    const container = c.get("container");
+    if (!container?.has(REALTIME_ROUTE_RUNTIME_CONTAINER_KEY)) {
+        return undefined;
+    }
+    return container.resolve(REALTIME_ROUTE_RUNTIME_CONTAINER_KEY);
+}
+/**
+ * Routes that mint short-lived, capability-scoped client tokens from the
+ * caller's session. Mounted as both `adminRoutes` and `publicRoutes`: the app's
+ * actor guards ensure `/v1/admin/*` carries a staff actor and `/v1/public/*` a
+ * customer/partner/supplier actor, and {@link resolveRealtimeCapabilities}
+ * scopes the token accordingly.
+ */
+export function createRealtimeRoutes(options = {}) {
+    // Eager runtime when providers are passed directly; otherwise rely on the
+    // container runtime registered at bootstrap (bindings-derived providers).
+    const eagerRuntime = options.providers && !options.resolveProviders
+        ? buildRealtimeRouteRuntime({}, options)
+        : undefined;
+    return new Hono().post("/token", async (c) => {
+        const runtime = eagerRuntime ?? getRuntime(c);
+        if (!runtime?.service) {
+            return c.json({ error: "Realtime provider is not configured" }, 503);
+        }
+        const service = runtime.service;
+        const actor = c.get("actor");
+        const userId = c.get("userId");
+        if (!userId || !actor) {
+            return c.json({ error: "Authentication required" }, 401);
+        }
+        const portalScope = actor !== "staff" && runtime.resolvePortalScope ? await runtime.resolvePortalScope(c) : null;
+        const capabilityCtx = { actor, userId, portalScope };
+        const capabilities = resolveRealtimeCapabilities(capabilityCtx);
+        const minted = await service.mintClientToken({
+            clientId: userId,
+            capabilities,
+            ttlSeconds: runtime.defaultTtlSeconds,
+        });
+        return c.json({
+            data: {
+                token: minted.token,
+                expiresAt: minted.expiresAt,
+                capabilities,
+                provider: service.defaultProvider.name,
+            },
+        });
+    });
+}

package/dist/service.d.ts

@@ -0,0 +1,21 @@
+import type { MintClientTokenInput, MintedClientToken, RealtimeMessage, RealtimeProvider } from "./types.js";
+export declare class RealtimeError extends Error {
+    constructor(message: string);
+}
+/**
+ * Thin router over one or more {@link RealtimeProvider}s. Most deployments use
+ * a single backend, so this mirrors `createNotificationService`: resolve a
+ * provider by name, defaulting to the first registered one.
+ */
+export interface RealtimeService {
+    /** Publish via the default provider (or the named one when `provider` set). */
+    publish(channel: string, message: RealtimeMessage, provider?: string): Promise<void>;
+    /** Mint a client token via the default provider (or the named one). */
+    mintClientToken(input: MintClientTokenInput, provider?: string): Promise<MintedClientToken>;
+    /** Look up a registered provider by name. */
+    getProvider(name: string): RealtimeProvider | undefined;
+    /** The provider used when no explicit name is given. */
+    readonly defaultProvider: RealtimeProvider;
+}
+export declare function createRealtimeService(providers: ReadonlyArray<RealtimeProvider>): RealtimeService;
+//# sourceMappingURL=service.d.ts.map

package/dist/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,oBAAoB,EACpB,iBAAiB,EACjB,eAAe,EACf,gBAAgB,EACjB,MAAM,YAAY,CAAA;AAEnB,qBAAa,aAAc,SAAQ,KAAK;gBAC1B,OAAO,EAAE,MAAM;CAI5B;AAED;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,+EAA+E;IAC/E,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACpF,uEAAuE;IACvE,eAAe,CAAC,KAAK,EAAE,oBAAoB,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAA;IAC3F,6CAA6C;IAC7C,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAAA;IACvD,wDAAwD;IACxD,QAAQ,CAAC,eAAe,EAAE,gBAAgB,CAAA;CAC3C;AAED,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,aAAa,CAAC,gBAAgB,CAAC,GAAG,eAAe,CAiCjG"}

package/dist/service.js

@@ -0,0 +1,38 @@
+export class RealtimeError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "RealtimeError";
+    }
+}
+export function createRealtimeService(providers) {
+    const first = providers[0];
+    if (!first) {
+        throw new RealtimeError("createRealtimeService requires at least one provider");
+    }
+    const defaultProvider = first;
+    const byName = new Map();
+    for (const provider of providers) {
+        byName.set(provider.name, provider);
+    }
+    function resolve(name) {
+        if (!name)
+            return defaultProvider;
+        const provider = byName.get(name);
+        if (!provider) {
+            throw new RealtimeError(`No realtime provider registered with name "${name}"`);
+        }
+        return provider;
+    }
+    return {
+        defaultProvider,
+        async publish(channel, message, provider) {
+            await resolve(provider).publish(channel, message);
+        },
+        async mintClientToken(input, provider) {
+            return resolve(provider).mintClientToken(input);
+        },
+        getProvider(name) {
+            return byName.get(name);
+        },
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,102 @@
+import type { EventEnvelope } from "@voyant-travel/core";
+/**
+ * A realtime capability granted on a channel. Mirrors the capability
+ * vocabulary the transport service understands.
+ */
+export type RealtimeCapability = "subscribe" | "publish" | "presence";
+/**
+ * Map of channel name (or pattern such as `booking:*`) to the capabilities
+ * the holder is granted on it.
+ */
+export type RealtimeCapabilities = Record<string, ReadonlyArray<RealtimeCapability>>;
+/**
+ * A message published to a channel. `event` follows the framework's
+ * `<resource>.<pastTenseAction>` convention; `data` is the payload subscribers
+ * receive. For the EventBus bridge the payload is an
+ * {@link RealtimeInvalidationHint}, never the entity itself.
+ */
+export interface RealtimeMessage {
+    event: string;
+    data: unknown;
+}
+/**
+ * Input for minting a short-lived client token a browser uses to connect to
+ * the transport. The token encodes the {@link RealtimeCapabilities} so the
+ * client can only subscribe to channels it is entitled to.
+ */
+export interface MintClientTokenInput {
+    /** Stable identifier for the connecting client (typically the user id). */
+    clientId: string;
+    /** Channels → capabilities the token grants. */
+    capabilities: RealtimeCapabilities;
+    /** Optional token lifetime; the provider applies its own default/cap. */
+    ttlSeconds?: number;
+}
+/**
+ * A minted client token plus its expiry, returned to the browser.
+ */
+export interface MintedClientToken {
+    token: string;
+    /** ISO-8601 timestamp at which the token stops being valid. */
+    expiresAt: string;
+}
+/**
+ * A pluggable realtime transport. Voyant Cloud is one implementation; any
+ * pub/sub backend (Ably, Pusher, Centrifugo, a self-hosted WebSocket/SSE
+ * service, …) can satisfy this interface.
+ *
+ * Built-in implementations:
+ * - `createLocalRealtimeProvider` — in-memory pub/sub for dev/tests and the
+ *   reference implementation.
+ * - `createVoyantCloudRealtimeProvider` — delegates to the Cloud SDK's
+ *   `realtime` namespace.
+ *
+ * Self-hosters who want a different backend implement this interface in their
+ * deployment and pass it to {@link createRealtimeBridge} and the token route.
+ */
+export interface RealtimeProvider {
+    /** Unique provider name (e.g. "voyant-cloud", "local", "ably"). */
+    readonly name: string;
+    /** Fan a message out to subscribers of `channel`. */
+    publish(channel: string, message: RealtimeMessage): Promise<void>;
+    /** Mint a short-lived, capability-scoped client token. */
+    mintClientToken(input: MintClientTokenInput): Promise<MintedClientToken>;
+}
+/**
+ * Default channel-message payload: an invalidation *hint*, not the entity.
+ *
+ * The React layer reacts by invalidating matching React Query keys and
+ * refetching over the existing authenticated HTTP path. This keeps HTTP the
+ * source of truth, makes at-most-once delivery acceptable (a missed hint
+ * self-heals on the next refetch/staleTime tick), and avoids leaking entity
+ * data through channel capabilities.
+ */
+export interface RealtimeInvalidationHint {
+    /** Originating domain event, e.g. `booking.confirmed`. */
+    event: string;
+    /** Entity family the hint concerns, e.g. `booking`. */
+    entity: string;
+    /** Optional id of the affected entity. */
+    id?: string;
+}
+/**
+ * Result a route function may return to customise the published message. The
+ * terse form — returning a `string[]` of channels — is also supported, in
+ * which case the hint defaults to `{ event, entity: <resource>, id: undefined }`.
+ */
+export interface RealtimeRouteResult {
+    channels: ReadonlyArray<string>;
+    /** Overrides merged onto the default {@link RealtimeInvalidationHint}. */
+    hint?: Partial<RealtimeInvalidationHint>;
+}
+/**
+ * Maps a domain event to the channels it should fan out to. Receives the
+ * event payload and the full envelope.
+ */
+export type RealtimeRoute<TData = unknown> = (data: TData, envelope: EventEnvelope<TData>) => ReadonlyArray<string> | RealtimeRouteResult;
+/**
+ * Declarative event → channel routing table for {@link createRealtimeBridge}.
+ * Keyed by domain event name.
+ */
+export type RealtimeRoutes = Record<string, RealtimeRoute>;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAExD;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAAG,WAAW,GAAG,SAAS,GAAG,UAAU,CAAA;AAErE;;;GAGG;AACH,MAAM,MAAM,oBAAoB,GAAG,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,kBAAkB,CAAC,CAAC,CAAA;AAEpF;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,OAAO,CAAA;CACd;AAED;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACnC,2EAA2E;IAC3E,QAAQ,EAAE,MAAM,CAAA;IAChB,gDAAgD;IAChD,YAAY,EAAE,oBAAoB,CAAA;IAClC,yEAAyE;IACzE,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAA;IACb,+DAA+D;IAC/D,SAAS,EAAE,MAAM,CAAA;CAClB;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,gBAAgB;IAC/B,mEAAmE;IACnE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,qDAAqD;IACrD,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACjE,0DAA0D;IAC1D,eAAe,CAAC,KAAK,EAAE,oBAAoB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAA;CACzE;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,wBAAwB;IACvC,0DAA0D;IAC1D,KAAK,EAAE,MAAM,CAAA;IACb,uDAAuD;IACvD,MAAM,EAAE,MAAM,CAAA;IACd,0CAA0C;IAC1C,EAAE,CAAC,EAAE,MAAM,CAAA;CACZ;AAED;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IAC/B,0EAA0E;IAC1E,IAAI,CAAC,EAAE,OAAO,CAAC,wBAAwB,CAAC,CAAA;CACzC;AAED;;;GAGG;AACH,MAAM,MAAM,aAAa,CAAC,KAAK,GAAG,OAAO,IAAI,CAC3C,IAAI,EAAE,KAAK,EACX,QAAQ,EAAE,aAAa,CAAC,KAAK,CAAC,KAC3B,aAAa,CAAC,MAAM,CAAC,GAAG,mBAAmB,CAAA;AAEhD;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,89 @@
+{
+  "name": "@voyant-travel/realtime",
+  "version": "0.1.0",
+  "license": "Apache-2.0",
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts",
+    "./types": "./src/types.ts",
+    "./service": "./src/service.ts",
+    "./bridge": "./src/bridge.ts",
+    "./capabilities": "./src/capabilities.ts",
+    "./routes": "./src/routes.ts",
+    "./providers/local": "./src/providers/local.ts",
+    "./providers/voyant-cloud": "./src/providers/voyant-cloud.ts"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check src/",
+    "test": "vitest run",
+    "build": "tsc -p tsconfig.json",
+    "clean": "rm -rf dist tsconfig.tsbuildinfo",
+    "prepack": "pnpm run build"
+  },
+  "dependencies": {
+    "@voyant-travel/core": "workspace:^",
+    "@voyant-travel/hono": "workspace:^",
+    "hono": "^4.12.10"
+  },
+  "devDependencies": {
+    "@voyant-travel/voyant-typescript-config": "workspace:^",
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.2"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "exports": {
+      ".": {
+        "types": "./dist/index.d.ts",
+        "import": "./dist/index.js",
+        "default": "./dist/index.js"
+      },
+      "./types": {
+        "types": "./dist/types.d.ts",
+        "import": "./dist/types.js",
+        "default": "./dist/types.js"
+      },
+      "./service": {
+        "types": "./dist/service.d.ts",
+        "import": "./dist/service.js",
+        "default": "./dist/service.js"
+      },
+      "./bridge": {
+        "types": "./dist/bridge.d.ts",
+        "import": "./dist/bridge.js",
+        "default": "./dist/bridge.js"
+      },
+      "./capabilities": {
+        "types": "./dist/capabilities.d.ts",
+        "import": "./dist/capabilities.js",
+        "default": "./dist/capabilities.js"
+      },
+      "./routes": {
+        "types": "./dist/routes.d.ts",
+        "import": "./dist/routes.js",
+        "default": "./dist/routes.js"
+      },
+      "./providers/local": {
+        "types": "./dist/providers/local.d.ts",
+        "import": "./dist/providers/local.js",
+        "default": "./dist/providers/local.js"
+      },
+      "./providers/voyant-cloud": {
+        "types": "./dist/providers/voyant-cloud.d.ts",
+        "import": "./dist/providers/voyant-cloud.js",
+        "default": "./dist/providers/voyant-cloud.js"
+      }
+    },
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/voyant-travel/voyant.git",
+    "directory": "packages/realtime"
+  }
+}