litestar-vite-plugin 0.27.0 → 0.28.0

package/dist/js/helpers/stream.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Resilient WebSocket and SSE helpers for Litestar event streams.
+ *
+ * @example
+ * ```ts
+ * import { createEventStream } from "litestar-vite-plugin/helpers"
+ *
+ * const stream = createEventStream({
+ *   url: "/events",
+ *   onEvent: (event) => console.log(event),
+ * })
+ *
+ * stream.connect()
+ * ```
+ *
+ * @module
+ */
+export interface StreamGap {
+    stream: string;
+    from: number;
+    to: number;
+    missing: number;
+}
+export type EventStreamTransport = "websocket" | "sse";
+export type StreamUrl = string | URL | (() => string | URL);
+export interface EventStreamConfig<TFrame = unknown> {
+    transport?: "websocket" | "sse";
+    sseEvents?: readonly string[];
+    onEvent: (frame: TFrame) => void;
+    onOpen?: (url: string) => void;
+    onClose?: () => void;
+    onHealthChange?: (healthy: boolean) => void;
+    onReconnect?: () => void;
+    onGap?: (gap: StreamGap) => void;
+    shouldReconnect?: (closeCode: number) => boolean;
+    isHeartbeat?: (frame: TFrame) => boolean;
+    getEventKey?: (frame: TFrame) => string | undefined;
+    getSequence?: (frame: TFrame) => {
+        stream: string;
+        value: number;
+    } | undefined;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+    dedupWindow?: number;
+    parseFrame?: (data: string) => TFrame;
+    WebSocketCtor?: typeof WebSocket;
+    EventSourceCtor?: typeof EventSource;
+}
+export type EventStreamOptions<TFrame = unknown> = EventStreamConfig<TFrame> & ({
+    url: StreamUrl;
+    buildUrl?: never;
+} | {
+    url?: never;
+    buildUrl: () => string | URL;
+});
+export interface EventStream {
+    connect(): void;
+    dispose(): void;
+    readonly healthy: boolean;
+}
+/**
+ * Resolve a stream endpoint against the browser origin.
+ *
+ * @param value - Absolute or same-origin relative endpoint.
+ * @param transport - Transport whose URL protocol should be used.
+ * @param baseUrl - Resolution base. Defaults to the current browser location.
+ * @returns An absolute transport URL.
+ */
+export declare function resolveStreamUrl(value: string | URL, transport: EventStreamTransport, baseUrl?: string | URL): string;
+/**
+ * Create a reconnecting, transport-agnostic Litestar event stream.
+ *
+ * @param options - Stream transport, lifecycle, and frame-processing options.
+ * @returns A disposable stream that connects only when `connect()` is called.
+ */
+export declare function createEventStream<TFrame = unknown>(options: EventStreamOptions<TFrame>): EventStream;

package/dist/js/helpers/stream.js

@@ -0,0 +1,242 @@
+/**
+ * Resilient WebSocket and SSE helpers for Litestar event streams.
+ *
+ * @example
+ * ```ts
+ * import { createEventStream } from "litestar-vite-plugin/helpers"
+ *
+ * const stream = createEventStream({
+ *   url: "/events",
+ *   onEvent: (event) => console.log(event),
+ * })
+ *
+ * stream.connect()
+ * ```
+ *
+ * @module
+ */
+const DEFAULT_BASE_DELAY_MS = 1000;
+const DEFAULT_MAX_DELAY_MS = 10_000;
+const DEFAULT_DEDUP_WINDOW = 1024;
+const DEFAULT_SSE_EVENTS = ["message"];
+function defaultParseFrame(data) {
+    try {
+        return JSON.parse(data);
+    }
+    catch {
+        return data;
+    }
+}
+/**
+ * Resolve a stream endpoint against the browser origin.
+ *
+ * @param value - Absolute or same-origin relative endpoint.
+ * @param transport - Transport whose URL protocol should be used.
+ * @param baseUrl - Resolution base. Defaults to the current browser location.
+ * @returns An absolute transport URL.
+ */
+export function resolveStreamUrl(value, transport, baseUrl = window.location.href) {
+    const resolved = new URL(value, baseUrl);
+    if (transport === "websocket") {
+        if (resolved.protocol === "http:") {
+            resolved.protocol = "ws:";
+        }
+        else if (resolved.protocol === "https:") {
+            resolved.protocol = "wss:";
+        }
+    }
+    else if (resolved.protocol === "ws:") {
+        resolved.protocol = "http:";
+    }
+    else if (resolved.protocol === "wss:") {
+        resolved.protocol = "https:";
+    }
+    return resolved.toString();
+}
+/**
+ * Create a reconnecting, transport-agnostic Litestar event stream.
+ *
+ * @param options - Stream transport, lifecycle, and frame-processing options.
+ * @returns A disposable stream that connects only when `connect()` is called.
+ */
+export function createEventStream(options) {
+    const { transport = "websocket", sseEvents = DEFAULT_SSE_EVENTS, onEvent, onOpen, onClose, onHealthChange, onReconnect, onGap, shouldReconnect = (closeCode) => closeCode !== 1000, isHeartbeat = () => false, getEventKey = () => undefined, getSequence = () => undefined, baseDelayMs = DEFAULT_BASE_DELAY_MS, maxDelayMs = DEFAULT_MAX_DELAY_MS, dedupWindow = DEFAULT_DEDUP_WINDOW, parseFrame = defaultParseFrame, } = options;
+    let connection = null;
+    let attempt = 0;
+    let timer = null;
+    let disposed = false;
+    let lastHealthy = null;
+    let hasOpened = false;
+    const seenKeys = [];
+    const seenKeySet = new Set();
+    const sequenceByStream = new Map();
+    function emitHealth(healthy) {
+        if (lastHealthy === healthy) {
+            return;
+        }
+        lastHealthy = healthy;
+        onHealthChange?.(healthy);
+    }
+    function clearTimer() {
+        if (timer !== null) {
+            clearTimeout(timer);
+            timer = null;
+        }
+    }
+    function scheduleReconnect() {
+        clearTimer();
+        attempt += 1;
+        const ceiling = Math.min(baseDelayMs * 2 ** (attempt - 1), maxDelayMs);
+        const delay = Math.random() * ceiling;
+        timer = setTimeout(() => {
+            timer = null;
+            if (!disposed) {
+                open();
+            }
+        }, delay);
+    }
+    function handleOpen(url) {
+        attempt = 0;
+        clearTimer();
+        emitHealth(true);
+        onOpen?.(url);
+        if (hasOpened) {
+            onReconnect?.();
+        }
+        else {
+            hasOpened = true;
+        }
+    }
+    function handleMessage(event) {
+        const frame = parseFrame(String(event.data));
+        if (isHeartbeat(frame)) {
+            return;
+        }
+        const eventKey = getEventKey(frame);
+        if (eventKey !== undefined && dedupWindow > 0) {
+            if (seenKeySet.has(eventKey)) {
+                return;
+            }
+            seenKeys.push(eventKey);
+            seenKeySet.add(eventKey);
+            if (seenKeys.length > dedupWindow) {
+                const evicted = seenKeys.shift();
+                if (evicted !== undefined) {
+                    seenKeySet.delete(evicted);
+                }
+            }
+        }
+        const sequence = getSequence(frame);
+        if (sequence !== undefined && Number.isFinite(sequence.value)) {
+            const last = sequenceByStream.get(sequence.stream);
+            if (last === undefined) {
+                sequenceByStream.set(sequence.stream, sequence.value);
+            }
+            else if (sequence.value > last) {
+                sequenceByStream.set(sequence.stream, sequence.value);
+                if (sequence.value > last + 1) {
+                    onGap?.({
+                        stream: sequence.stream,
+                        from: last,
+                        to: sequence.value,
+                        missing: sequence.value - last - 1,
+                    });
+                }
+            }
+        }
+        onEvent(frame);
+    }
+    function buildConnectionUrl() {
+        const value = options.buildUrl === undefined ? options.url : options.buildUrl();
+        const endpoint = typeof value === "function" ? value() : value;
+        return resolveStreamUrl(endpoint, transport);
+    }
+    function openWebSocket() {
+        const WebSocketCtor = options.WebSocketCtor ?? window.WebSocket;
+        const url = buildConnectionUrl();
+        const next = new WebSocketCtor(url);
+        connection = next;
+        next.addEventListener("open", () => {
+            handleOpen(url);
+        });
+        next.addEventListener("message", (event) => {
+            handleMessage(event);
+        });
+        next.addEventListener("close", (event) => {
+            if (connection !== next) {
+                return;
+            }
+            connection = null;
+            onClose?.();
+            emitHealth(false);
+            if (disposed || !shouldReconnect(event.code)) {
+                return;
+            }
+            scheduleReconnect();
+        });
+        next.addEventListener("error", () => {
+            emitHealth(false);
+        });
+    }
+    function openEventSource() {
+        const EventSourceCtor = options.EventSourceCtor ?? window.EventSource;
+        const url = buildConnectionUrl();
+        const next = new EventSourceCtor(url);
+        connection = next;
+        next.addEventListener("open", () => {
+            handleOpen(url);
+        });
+        for (const eventType of sseEvents) {
+            next.addEventListener(eventType, (event) => {
+                handleMessage(event);
+            });
+        }
+        next.addEventListener("error", () => {
+            if (connection !== next) {
+                return;
+            }
+            connection = null;
+            next.close();
+            onClose?.();
+            emitHealth(false);
+            if (disposed || !shouldReconnect(1006)) {
+                return;
+            }
+            scheduleReconnect();
+        });
+    }
+    function open() {
+        if (disposed || typeof window === "undefined") {
+            return;
+        }
+        if (transport === "sse") {
+            openEventSource();
+            return;
+        }
+        openWebSocket();
+    }
+    return {
+        connect() {
+            if (disposed || typeof window === "undefined") {
+                return;
+            }
+            attempt = 0;
+            clearTimer();
+            open();
+        },
+        dispose() {
+            disposed = true;
+            clearTimer();
+            const current = connection;
+            connection = null;
+            if (current !== null) {
+                onClose?.();
+                emitHealth(false);
+                current.close();
+            }
+        },
+        get healthy() {
+            return lastHealthy ?? false;
+        },
+    };
+}

package/dist/js/index.js

@@ -7,6 +7,7 @@ import fullReload from "vite-plugin-full-reload";
 import { checkBackendAvailability, loadLitestarMeta } from "./litestar-meta.js";
 import { readBridgeConfig } from "./shared/bridge-schema.js";
 import { createLogger } from "./shared/logger.js";
+import { installManagedShutdown } from "./shared/managed-shutdown.js";
 import { resolveLitestarPort } from "./shared/network.js";
 import { resolveDefaultSdkClientPlugin } from "./shared/typegen-core.js";
 import { createLitestarTypeGenPlugin, resolveTypesConfig } from "./shared/typegen-plugin.js";
@@ -320,6 +321,9 @@ function resolveLitestarPlugin(pluginConfig) {
         }
       });
       if (!exitHandlersBound) {
+        installManagedShutdown(server, () => {
+          shuttingDown = true;
+        });
         const clean = () => {
           if (pluginConfig.hotFile && fs.existsSync(pluginConfig.hotFile)) {
             fs.rmSync(pluginConfig.hotFile);

package/dist/js/nuxt.js

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import colors from "picocolors";
 import { readBridgeConfig } from "./shared/bridge-schema.js";
+import { installManagedShutdown } from "./shared/managed-shutdown.js";
 import { normalizeHost, resolveHotFilePath, resolveLitestarPort } from "./shared/network.js";
 import { createLitestarTypeGenPlugin, resolveTypesConfig } from "./shared/typegen-plugin.js";
 import { hmrServerConfig } from "./shared/vite-compat.js";
@@ -105,6 +106,7 @@ function createProxyPlugin(config) {
       };
     },
     configureServer(server) {
+      installManagedShutdown(server);
       if (config.verbose) {
         server.middlewares.use((req, _res, next) => {
           if (req.url?.startsWith(config.apiPrefix)) {
@@ -186,26 +188,18 @@ function litestarNuxtModule(userOptions, nuxt) {
     console.log(colors.cyan("[litestar-nuxt]"), "Nitro devProxy configured:");
     console.log(JSON.stringify(nuxt.options.nitro.devProxy, null, 2));
   }
-  if (config.hotFile && config.devPort) {
-    const rawHost = process.env.NUXT_HOST || process.env.HOST || "127.0.0.1";
-    const host = normalizeHost(rawHost);
-    const url = `http://${host}:${config.devPort}`;
-    fs.mkdirSync(path.dirname(config.hotFile), { recursive: true });
-    fs.writeFileSync(config.hotFile, url);
-    if (config.verbose) {
-      console.log(colors.cyan("[litestar-nuxt]"), colors.dim(`Hotfile written: ${config.hotFile} -> ${url}`));
-    }
-  }
   if (nuxt.hook && config.hotFile) {
+    const hotFile = config.hotFile;
     nuxt.hook("listen", (_server, listener) => {
       const info = listener;
-      if (info && typeof info.port === "number") {
-        const host = normalizeHost(info.host || "127.0.0.1");
-        const url = `http://${host}:${info.port}`;
-        fs.mkdirSync(path.dirname(config.hotFile), { recursive: true });
-        fs.writeFileSync(config.hotFile, url);
+      const port = info?.address?.port ?? info?.port;
+      if (typeof port === "number") {
+        const host = normalizeHost(info.address?.address || info.host || "127.0.0.1");
+        const url = `http://${host}:${port}`;
+        fs.mkdirSync(path.dirname(hotFile), { recursive: true });
+        fs.writeFileSync(hotFile, url);
         if (config.verbose) {
-          console.log(colors.cyan("[litestar-nuxt]"), colors.dim(`Hotfile updated via listen hook: ${url}`));
+          console.log(colors.cyan("[litestar-nuxt]"), colors.dim(`Hotfile written after listen: ${hotFile} -> ${url}`));
         }
       }
     });

package/dist/js/react/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * React bindings for generic and Litestar Queues event streams.
+ *
+ * @module
+ */
+import { type EventStreamOptions, type QueueEventStreamOptions, type StreamGap } from "litestar-vite-plugin/helpers";
+export interface EventStreamState<TFrame> {
+    healthy: boolean;
+    lastEvent: TFrame | null;
+    lastGap: StreamGap | null;
+    events: TFrame[];
+}
+export type ReactEventStreamOptions<TFrame> = EventStreamOptions<TFrame> & {
+    key: string;
+    bufferSize?: number;
+};
+export type ReactQueueEventStreamOptions<TFrame> = QueueEventStreamOptions<TFrame> & {
+    key: string;
+    bufferSize?: number;
+};
+/**
+ * Subscribe a React component to a generic event stream.
+ */
+export declare function useEventStream<TFrame = unknown>(options: ReactEventStreamOptions<TFrame>): EventStreamState<TFrame>;
+/**
+ * Subscribe a React component to a Litestar Queues event stream.
+ */
+export declare function useQueueEventStream<TFrame = unknown>(options: ReactQueueEventStreamOptions<TFrame>): EventStreamState<TFrame>;

package/dist/js/react/index.js

@@ -0,0 +1,54 @@
+/**
+ * React bindings for generic and Litestar Queues event streams.
+ *
+ * @module
+ */
+import { createEventStream, createQueueEventStream } from "litestar-vite-plugin/helpers";
+import { useEffect, useRef, useState } from "react";
+function initialState() {
+    return { events: [], healthy: false, lastEvent: null, lastGap: null };
+}
+function useStream(factory, options) {
+    const optionsRef = useRef(options);
+    optionsRef.current = options;
+    const [state, setState] = useState(initialState);
+    const transport = options.transport ?? "websocket";
+    useEffect(() => {
+        setState(initialState);
+        const { bufferSize: _bufferSize, key: _key, ...streamOptions } = optionsRef.current;
+        const stream = factory({
+            ...streamOptions,
+            onEvent: (frame) => {
+                optionsRef.current.onEvent(frame);
+                setState((current) => {
+                    const bufferSize = Math.max(0, optionsRef.current.bufferSize ?? 100);
+                    const events = bufferSize === 0 ? [] : [...current.events, frame].slice(-bufferSize);
+                    return { ...current, events, lastEvent: frame };
+                });
+            },
+            onGap: (gap) => {
+                optionsRef.current.onGap?.(gap);
+                setState((current) => ({ ...current, lastGap: gap }));
+            },
+            onHealthChange: (healthy) => {
+                optionsRef.current.onHealthChange?.(healthy);
+                setState((current) => ({ ...current, healthy }));
+            },
+        });
+        stream.connect();
+        return () => stream.dispose();
+    }, [factory, options.key, transport]);
+    return state;
+}
+/**
+ * Subscribe a React component to a generic event stream.
+ */
+export function useEventStream(options) {
+    return useStream(createEventStream, options);
+}
+/**
+ * Subscribe a React component to a Litestar Queues event stream.
+ */
+export function useQueueEventStream(options) {
+    return useStream(createQueueEventStream, options);
+}

package/dist/js/shared/bridge-schema.d.ts

@@ -37,9 +37,9 @@ export interface BridgeSchema {
     appUrl: string | null;
     /**
      * Litestar dev server port. Used by framework integrations to set
-     * `vite.server.hmr.clientPort`, ensuring the browser connects to Litestar
-     * (not the framework dev server) for HMR — preserving the single-port
-     * contract.
+     * `vite.server.ws.clientPort` on Vite 8.1+ (`vite.server.hmr.clientPort` on
+     * Vite 7 / 8.0), ensuring the browser connects to Litestar (not the framework
+     * dev server) for HMR — preserving the single-port contract.
      */
     litestarPort: number | null;
     bundleDir: string;

package/dist/js/shared/managed-shutdown.d.ts

@@ -0,0 +1,8 @@
+import type { ViteDevServer } from "vite";
+/**
+ * Close a Python-managed Vite sidecar when its stdin pipe reaches EOF.
+ *
+ * @param server - Vite server owned by the Python parent process.
+ * @param markShuttingDown - Optional callback for integration-specific shutdown state.
+ */
+export declare function installManagedShutdown(server: ViteDevServer, markShuttingDown?: () => void): void;

package/dist/js/shared/managed-shutdown.js

@@ -0,0 +1,26 @@
+const installedServers = /* @__PURE__ */ new WeakSet();
+function installManagedShutdown(server, markShuttingDown) {
+  if (process.env.LITESTAR_VITE_MANAGED !== "1" || installedServers.has(server)) {
+    return;
+  }
+  installedServers.add(server);
+  let shuttingDown = false;
+  const shutdown = async () => {
+    if (shuttingDown) {
+      return;
+    }
+    shuttingDown = true;
+    markShuttingDown?.();
+    try {
+      await server.close();
+    } finally {
+      process.exit(0);
+    }
+  };
+  process.stdin.on("end", shutdown);
+  process.stdin.on("close", shutdown);
+  process.stdin.resume();
+}
+export {
+  installManagedShutdown
+};

package/dist/js/shared/network.d.ts

@@ -25,9 +25,10 @@ export declare function normalizeHost(host: string): string;
  * Resolve the Litestar dev server port for HMR routing.
  *
  * Framework integrations (Astro/Nuxt/SvelteKit) need this port to set
- * `vite.server.hmr.clientPort` so the browser opens the HMR WebSocket against
- * Litestar — NOT the framework dev server's port — preserving the
- * single-port-via-ASGI contract.
+ * `vite.server.ws.clientPort` on Vite 8.1+ (`vite.server.hmr.clientPort` on
+ * Vite 7 / 8.0) so the browser opens the HMR WebSocket against Litestar — NOT
+ * the framework dev server's port — preserving the single-port-via-ASGI
+ * contract.
  *
  * Resolution order:
  *   1. `bridge.litestarPort` (preferred; written by Python ≥0.23.0).

package/dist/js/svelte/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Svelte stores for generic and Litestar Queues event streams.
+ *
+ * @module
+ */
+import { type EventStreamOptions, type QueueEventStreamOptions, type StreamGap } from "litestar-vite-plugin/helpers";
+import { type Readable } from "svelte/store";
+export interface EventStreamStoreState<TFrame> {
+    healthy: boolean;
+    lastEvent: TFrame | null;
+    lastGap: StreamGap | null;
+    events: TFrame[];
+}
+export type SvelteEventStreamOptions<TFrame> = EventStreamOptions<TFrame> & {
+    bufferSize?: number;
+};
+export type SvelteQueueEventStreamOptions<TFrame> = QueueEventStreamOptions<TFrame> & {
+    bufferSize?: number;
+};
+/**
+ * Create a readable store backed by a generic event stream.
+ */
+export declare function createEventStreamStore<TFrame = unknown>(options: SvelteEventStreamOptions<TFrame>): Readable<EventStreamStoreState<TFrame>>;
+/**
+ * Create a readable store backed by a Litestar Queues event stream.
+ */
+export declare function createQueueEventStreamStore<TFrame = unknown>(options: SvelteQueueEventStreamOptions<TFrame>): Readable<EventStreamStoreState<TFrame>>;

package/dist/js/svelte/index.js

@@ -0,0 +1,51 @@
+/**
+ * Svelte stores for generic and Litestar Queues event streams.
+ *
+ * @module
+ */
+import { createEventStream, createQueueEventStream } from "litestar-vite-plugin/helpers";
+import { readable } from "svelte/store";
+function initialState() {
+    return { events: [], healthy: false, lastEvent: null, lastGap: null };
+}
+function createStreamStore(factory, options) {
+    return readable(initialState(), (set) => {
+        let state = initialState();
+        const update = (next) => {
+            state = { ...state, ...next };
+            set(state);
+        };
+        const { bufferSize: _bufferSize, ...streamOptions } = options;
+        const stream = factory({
+            ...streamOptions,
+            onEvent: (frame) => {
+                options.onEvent(frame);
+                const bufferSize = Math.max(0, options.bufferSize ?? 100);
+                const events = bufferSize === 0 ? [] : [...state.events, frame].slice(-bufferSize);
+                update({ events, lastEvent: frame });
+            },
+            onGap: (gap) => {
+                options.onGap?.(gap);
+                update({ lastGap: gap });
+            },
+            onHealthChange: (healthy) => {
+                options.onHealthChange?.(healthy);
+                update({ healthy });
+            },
+        });
+        stream.connect();
+        return () => stream.dispose();
+    });
+}
+/**
+ * Create a readable store backed by a generic event stream.
+ */
+export function createEventStreamStore(options) {
+    return createStreamStore(createEventStream, options);
+}
+/**
+ * Create a readable store backed by a Litestar Queues event stream.
+ */
+export function createQueueEventStreamStore(options) {
+    return createStreamStore(createQueueEventStream, options);
+}

package/dist/js/sveltekit.js

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import colors from "picocolors";
 import { readBridgeConfig } from "./shared/bridge-schema.js";
+import { installManagedShutdown } from "./shared/managed-shutdown.js";
 import { normalizeHost, resolveHotFilePath, resolveLitestarPort } from "./shared/network.js";
 import { createLitestarTypeGenPlugin, resolveTypesConfig } from "./shared/typegen-plugin.js";
 import { hmrServerConfig } from "./shared/vite-compat.js";
@@ -97,6 +98,7 @@ function litestarSvelteKit(userConfig = {}) {
       };
     },
     configureServer(server) {
+      installManagedShutdown(server);
       if (config.verbose) {
         server.middlewares.use((req, _res, next) => {
           if (req.url?.startsWith(config.apiPrefix)) {

package/dist/js/vue/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Vue bindings for generic and Litestar Queues event streams.
+ *
+ * @module
+ */
+import { type EventStreamOptions, type QueueEventStreamOptions, type StreamGap } from "litestar-vite-plugin/helpers";
+import { type MaybeRefOrGetter, type Ref, type ShallowRef } from "vue";
+export interface VueEventStreamState<TFrame> {
+    healthy: Ref<boolean>;
+    lastEvent: ShallowRef<TFrame | null>;
+    lastGap: ShallowRef<StreamGap | null>;
+    events: ShallowRef<TFrame[]>;
+}
+export type VueEventStreamOptions<TFrame> = EventStreamOptions<TFrame> & {
+    key: MaybeRefOrGetter<string>;
+    bufferSize?: number;
+};
+export type VueQueueEventStreamOptions<TFrame> = QueueEventStreamOptions<TFrame> & {
+    key: MaybeRefOrGetter<string>;
+    bufferSize?: number;
+};
+/**
+ * Subscribe a Vue scope to a generic event stream.
+ */
+export declare function useEventStream<TFrame = unknown>(options: VueEventStreamOptions<TFrame>): VueEventStreamState<TFrame>;
+/**
+ * Subscribe a Vue scope to a Litestar Queues event stream.
+ */
+export declare function useQueueEventStream<TFrame = unknown>(options: VueQueueEventStreamOptions<TFrame>): VueEventStreamState<TFrame>;