@langchain/vue 0.4.7 → 1.0.1

package/dist/selectors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectors.js","names":[],"sources":["../src/selectors.ts"],"sourcesContent":["import {\n  computed,\n  onScopeDispose,\n  readonly,\n  shallowRef,\n  toValue,\n  type ComputedRef,\n  type MaybeRefOrGetter,\n  type ShallowRef,\n} from \"vue\";\nimport type { BaseMessage } from \"@langchain/core/messages\";\nimport {\n  NAMESPACE_SEPARATOR,\n  audioProjection,\n  channelProjection,\n  extensionProjection,\n  filesProjection,\n  imagesProjection,\n  messagesProjection,\n  toolCallsProjection,\n  valuesProjection,\n  videoProjection,\n  type AssembledToolCall,\n  type AudioMedia,\n  type Channel,\n  type ChannelProjectionOptions,\n  type Event,\n  type FileMedia,\n  type ImageMedia,\n  type InferStateType,\n  type MessageMetadata,\n  type MessageMetadataMap,\n  type SubagentDiscoverySnapshot,\n  type SubgraphDiscoverySnapshot,\n  type SubmissionQueueEntry,\n  type SubmissionQueueSnapshot,\n  type VideoMedia,\n} from \"@langchain/langgraph-sdk/stream\";\nimport {\n  getRegistry,\n  STREAM_CONTROLLER,\n  type AnyStream,\n  type UseStreamReturn,\n} from \"./use-stream.js\";\nimport { useProjection } from \"./use-projection.js\";\n\n/**\n * Selector composables don't need to carry `InterruptType` /\n * `ConfigurableType`. Parameterising on `StateType` alone lets\n * callers with a full `useStream<S, I, C>()` handle pass it in without\n * redeclaring those generics at every call site.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype StreamHandle<StateType extends object> = UseStreamReturn<\n  StateType,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  any,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  any\n>;\n\n/**\n * What a selector composable can be targeted at. Callers can pass:\n *  - `undefined` / `null` — root namespace (served by the always-on\n *    root store — no extra subscription);\n *  - a {@link SubagentDiscoverySnapshot} (`stream.subagents.value.get(...)`);\n *  - a {@link SubgraphDiscoverySnapshot} (`stream.subgraphs.value.get(...)`);\n *  - an explicit `{ namespace: string[] }`;\n *  - a raw `string[]` escape hatch.\n */\nexport type SelectorTarget =\n  | undefined\n  | null\n  | readonly string[]\n  | { namespace: readonly string[] }\n  | SubagentDiscoverySnapshot\n  | SubgraphDiscoverySnapshot;\n\nconst EMPTY_NAMESPACE: readonly string[] = [];\n\nfunction resolveNamespace(target: SelectorTarget): readonly string[] {\n  if (target == null) return EMPTY_NAMESPACE;\n  if (Array.isArray(target)) return target as readonly string[];\n  const obj = target as { namespace?: readonly string[] };\n  return obj.namespace ?? EMPTY_NAMESPACE;\n}\n\nfunction isRoot(namespace: readonly string[]): boolean {\n  return namespace.length === 0;\n}\n\nfunction namespaceKey(namespace: readonly string[]): string {\n  return namespace.join(NAMESPACE_SEPARATOR);\n}\n\n/**\n * Subscribe to a scoped `messages` stream.\n *\n * Contract:\n *  - At the root (no `target`) this returns `stream.messages` — the\n *    always-on root projection; no extra subscription is opened.\n *  - For any non-root namespace, mount triggers a ref-counted\n *    `messages` subscription scoped to that namespace. The\n *    subscription is released automatically when the calling scope\n *    disappears (and the registry closes the underlying server\n *    subscription when the last consumer leaves).\n *\n * Messages are always `BaseMessage` class instances from\n * `@langchain/core/messages`.\n */\nexport function useMessages(\n  stream: AnyStream,\n  target?: MaybeRefOrGetter<SelectorTarget>\n): Readonly<ShallowRef<BaseMessage[]>> {\n  const namespace = computed(() => resolveNamespace(toValue(target)));\n  if (isRoot(namespace.value)) return stream.messages;\n  const key = computed(() => `messages|${namespaceKey(namespace.value)}`);\n  return useProjection<BaseMessage[]>(\n    getRegistry(stream),\n    () => messagesProjection(namespace.value),\n    key,\n    EMPTY_MESSAGES\n  );\n}\n\nconst EMPTY_MESSAGES: BaseMessage[] = [];\n\n/**\n * Subscribe to a scoped `tools` (tool-call) stream. Same target and\n * lifecycle rules as {@link useMessages}; at the root this returns\n * `stream.toolCalls` directly.\n */\nexport function useToolCalls(\n  stream: AnyStream,\n  target?: MaybeRefOrGetter<SelectorTarget>\n): Readonly<ShallowRef<AssembledToolCall[]>> {\n  const namespace = computed(() => resolveNamespace(toValue(target)));\n  if (isRoot(namespace.value)) return stream.toolCalls;\n  const key = computed(() => `toolCalls|${namespaceKey(namespace.value)}`);\n  return useProjection<AssembledToolCall[]>(\n    getRegistry(stream),\n    () => toolCallsProjection(namespace.value),\n    key,\n    EMPTY_TOOLCALLS\n  );\n}\n\nconst EMPTY_TOOLCALLS: AssembledToolCall[] = [];\n\n/**\n * Subscribe to a scoped `values` stream — the most recent state\n * payload for a namespace. At the root returns `stream.values`.\n *\n * Typing:\n *  - **Root** (`useValues(stream)`): returns the `StateType` declared\n *    on `useStream<State>()` — non-nullable (the root snapshot always\n *    has values, falling back to `initialValues ?? {}`).\n *  - **Scoped** (`useValues(stream, target)`): scoped payloads can\n *    differ from the root state; callers should annotate the\n *    expected shape explicitly (`useValues<SubagentState>(stream,\n *    sub)`). Defaults to `unknown` when not annotated.\n */\nexport function useValues<StateType extends object>(\n  stream: StreamHandle<StateType>\n): Readonly<ShallowRef<StateType>>;\nexport function useValues<T>(\n  stream: AnyStream\n): Readonly<ShallowRef<InferStateType<T>>>;\nexport function useValues<T = unknown>(\n  stream: AnyStream,\n  target: SelectorTarget,\n  options?: { messagesKey?: string }\n): Readonly<ShallowRef<T | undefined>>;\nexport function useValues(\n  stream: AnyStream,\n  target?: SelectorTarget,\n  options?: { messagesKey?: string }\n): Readonly<ShallowRef<unknown>> {\n  const namespace = resolveNamespace(target);\n  if (isRoot(namespace)) return stream.values as Readonly<ShallowRef<unknown>>;\n  const messagesKey = options?.messagesKey ?? \"messages\";\n  const key = `values|${messagesKey}|${namespaceKey(namespace)}`;\n  return useProjection<unknown>(\n    getRegistry(stream),\n    () => valuesProjection<unknown>(namespace, messagesKey),\n    key,\n    undefined\n  );\n}\n\n/**\n * Subscribe to a `custom:<name>` stream extension — most-recent\n * payload emitted by the transformer, scoped to the target namespace.\n */\nexport function useExtension<T = unknown>(\n  stream: AnyStream,\n  name: string,\n  target?: SelectorTarget\n): Readonly<ShallowRef<T | undefined>> {\n  const namespace = resolveNamespace(target);\n  const key = `extension|${name}|${namespaceKey(namespace)}`;\n  return useProjection<T | undefined>(\n    getRegistry(stream),\n    () => extensionProjection<T>(name, namespace),\n    key,\n    undefined\n  );\n}\n\n/**\n * Raw-events escape hatch. Subscribes to one or more channels at a\n * namespace and returns a bounded buffer of raw protocol events.\n * Prefer {@link useMessages} / {@link useToolCalls} / {@link useValues}\n * for the common cases.\n */\nexport type UseChannelOptions = ChannelProjectionOptions;\n\nexport function useChannel(\n  stream: AnyStream,\n  channels: readonly Channel[],\n  target?: SelectorTarget,\n  options?: UseChannelOptions\n): Readonly<ShallowRef<Event[]>> {\n  const namespace = resolveNamespace(target);\n  const sortedChannels = [...channels].sort().join(\",\");\n  const key = `channel|${options?.bufferSize ?? \"default\"}|${(options?.replay ?? true) ? \"replay\" : \"live\"}|${sortedChannels}|${namespaceKey(namespace)}`;\n  return useProjection<Event[]>(\n    getRegistry(stream),\n    () => channelProjection(channels, namespace, options),\n    key,\n    EMPTY_EVENTS\n  );\n}\n\nconst EMPTY_EVENTS: Event[] = [];\n\n/**\n * Subscribe to a scoped audio-media stream. Each handle is yielded\n * on its first matching `content-block-start`, exposes\n * `.partialBytes` for live access, settles `.blob` / `.objectURL` /\n * `.transcript` on `message-finish`, and surfaces errors via\n * `.error`.\n */\nexport function useAudio(\n  stream: AnyStream,\n  target?: SelectorTarget\n): Readonly<ShallowRef<AudioMedia[]>> {\n  const namespace = resolveNamespace(target);\n  const key = `audio|${namespaceKey(namespace)}`;\n  return useProjection<AudioMedia[]>(\n    getRegistry(stream),\n    () => audioProjection(namespace),\n    key,\n    EMPTY_AUDIO\n  );\n}\n\nconst EMPTY_AUDIO: AudioMedia[] = [];\n\n/**\n * Subscribe to a scoped image-media stream. Pair with\n * {@link useMediaURL} for `<img src>`.\n */\nexport function useImages(\n  stream: AnyStream,\n  target?: SelectorTarget\n): Readonly<ShallowRef<ImageMedia[]>> {\n  const namespace = resolveNamespace(target);\n  const key = `images|${namespaceKey(namespace)}`;\n  return useProjection<ImageMedia[]>(\n    getRegistry(stream),\n    () => imagesProjection(namespace),\n    key,\n    EMPTY_IMAGES\n  );\n}\n\nconst EMPTY_IMAGES: ImageMedia[] = [];\n\n/**\n * Subscribe to a scoped video-media stream. Pair with\n * {@link useMediaURL} for `<video src>`.\n */\nexport function useVideo(\n  stream: AnyStream,\n  target?: SelectorTarget\n): Readonly<ShallowRef<VideoMedia[]>> {\n  const namespace = resolveNamespace(target);\n  const key = `video|${namespaceKey(namespace)}`;\n  return useProjection<VideoMedia[]>(\n    getRegistry(stream),\n    () => videoProjection(namespace),\n    key,\n    EMPTY_VIDEO\n  );\n}\n\nconst EMPTY_VIDEO: VideoMedia[] = [];\n\n/**\n * Subscribe to a scoped file-media stream. Pair with\n * {@link useMediaURL} for an `<a download href>` target.\n */\nexport function useFiles(\n  stream: AnyStream,\n  target?: SelectorTarget\n): Readonly<ShallowRef<FileMedia[]>> {\n  const namespace = resolveNamespace(target);\n  const key = `files|${namespaceKey(namespace)}`;\n  return useProjection<FileMedia[]>(\n    getRegistry(stream),\n    () => filesProjection(namespace),\n    key,\n    EMPTY_FILES\n  );\n}\n\nconst EMPTY_FILES: FileMedia[] = [];\n\n/**\n * Read metadata recorded for a specific message id — today exposes\n * `parentCheckpointId`, the checkpoint the message was first seen on.\n * Designed for fork / edit flows:\n *\n * ```ts\n * const meta = useMessageMetadata(stream, () => msg.id);\n * // meta.value?.parentCheckpointId\n * ```\n *\n * `messageId` accepts a raw string, a `Ref<string | undefined>`, or\n * a getter — the binding re-evaluates whenever the id changes.\n */\nexport function useMessageMetadata(\n  stream: AnyStream,\n  messageId: MaybeRefOrGetter<string | undefined>\n): ComputedRef<MessageMetadata | undefined> {\n  const store = stream[STREAM_CONTROLLER].messageMetadataStore;\n  const mapRef = shallowRef<MessageMetadataMap>(store.getSnapshot());\n  const unsubscribe = store.subscribe(() => {\n    mapRef.value = store.getSnapshot();\n  });\n  onScopeDispose(unsubscribe);\n\n  return computed<MessageMetadata | undefined>(() => {\n    const key = toValue(messageId);\n    if (key == null) return undefined;\n    return mapRef.value.get(key);\n  });\n}\n\n/**\n * Reactive handle on the server-side submission queue.\n *\n * Populated when `submit()` is invoked with\n * `multitaskStrategy: \"enqueue\"` while another run is in flight. The\n * returned refs are shared per call — safe to pass into `v-for`.\n */\nexport interface UseSubmissionQueueReturn<\n  StateType extends object = Record<string, unknown>,\n> {\n  readonly entries: Readonly<ShallowRef<SubmissionQueueSnapshot<StateType>>>;\n  readonly size: ComputedRef<number>;\n  cancel(id: string): Promise<boolean>;\n  clear(): Promise<void>;\n}\n\nexport function useSubmissionQueue<StateType extends object>(\n  stream: StreamHandle<StateType>\n): UseSubmissionQueueReturn<StateType>;\nexport function useSubmissionQueue(stream: AnyStream): UseSubmissionQueueReturn;\nexport function useSubmissionQueue(\n  stream: AnyStream\n): UseSubmissionQueueReturn {\n  const controller = stream[STREAM_CONTROLLER];\n  const store = controller.queueStore;\n  const entries = shallowRef<SubmissionQueueSnapshot>(store.getSnapshot());\n  const unsubscribe = store.subscribe(() => {\n    entries.value = store.getSnapshot();\n  });\n  onScopeDispose(unsubscribe);\n\n  return {\n    entries: readonly(entries) as Readonly<ShallowRef<SubmissionQueueSnapshot>>,\n    size: computed(() => entries.value.length),\n    cancel: (id) => controller.cancelQueued(id),\n    clear: () => controller.clearQueue(),\n  };\n}\n\nexport type { SubmissionQueueEntry, SubmissionQueueSnapshot };\n"],"mappings":"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"}

package/dist/use-audio-player.cjs

@@ -0,0 +1,591 @@
+let vue = require("vue");
+//#region src/use-audio-player.ts
+const DEFAULT_SAMPLE_RATE = 24e3;
+const DEFAULT_CHANNELS = 1;
+const ANALYSER_FFT_SIZE = 512;
+/**
+* Module-level registry of shared readers keyed by {@link MediaBase}
+* identity. See the React binding for the full rationale — keying on
+* identity (WeakMap) keeps the pump stable across remounts and
+* simultaneous consumers while letting GC reclaim entries alongside
+* their media handles.
+*/
+const pumpRegistry = /* @__PURE__ */ new WeakMap();
+function attachToPump(media, listener) {
+	let controller = pumpRegistry.get(media);
+	if (controller == null) {
+		const reader = media.stream.getReader();
+		controller = {
+			chunks: [],
+			finished: false,
+			error: void 0,
+			listeners: /* @__PURE__ */ new Set()
+		};
+		pumpRegistry.set(media, controller);
+		const owned = controller;
+		(async () => {
+			try {
+				while (true) {
+					const { value, done } = await reader.read();
+					if (done) break;
+					if (value == null || value.byteLength === 0) continue;
+					owned.chunks.push(value);
+					for (const l of owned.listeners) try {
+						l({
+							type: "chunk",
+							bytes: value
+						});
+					} catch {}
+				}
+				owned.finished = true;
+				for (const l of owned.listeners) try {
+					l({ type: "finished" });
+				} catch {}
+			} catch (err) {
+				owned.error = err;
+				for (const l of owned.listeners) try {
+					l({
+						type: "error",
+						error: err
+					});
+				} catch {}
+			} finally {
+				try {
+					reader.releaseLock();
+				} catch {}
+			}
+		})();
+	}
+	for (const chunk of controller.chunks) listener({
+		type: "chunk",
+		bytes: chunk
+	});
+	if (controller.finished) listener({ type: "finished" });
+	if (controller.error != null) listener({
+		type: "error",
+		error: controller.error
+	});
+	controller.listeners.add(listener);
+	return () => {
+		controller.listeners.delete(listener);
+	};
+}
+function tryParseWavHeader(bytes) {
+	if (bytes.byteLength < 12) return { status: "need-more" };
+	if (bytes[0] !== 82 || bytes[1] !== 73 || bytes[2] !== 70 || bytes[3] !== 70 || bytes[8] !== 87 || bytes[9] !== 65 || bytes[10] !== 86 || bytes[11] !== 69) return {
+		status: "invalid",
+		reason: "not a RIFF/WAVE stream"
+	};
+	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	let fmt = null;
+	let offset = 12;
+	while (offset + 8 <= bytes.byteLength) {
+		const id = String.fromCharCode(bytes[offset], bytes[offset + 1], bytes[offset + 2], bytes[offset + 3]);
+		const size = view.getUint32(offset + 4, true);
+		const payloadStart = offset + 8;
+		if (id === "fmt ") {
+			if (payloadStart + 16 > bytes.byteLength) return { status: "need-more" };
+			fmt = {
+				audioFormat: view.getUint16(payloadStart, true),
+				channels: view.getUint16(payloadStart + 2, true),
+				sampleRate: view.getUint32(payloadStart + 4, true),
+				bitsPerSample: view.getUint16(payloadStart + 14, true)
+			};
+			if (fmt.audioFormat !== 1) return {
+				status: "invalid",
+				reason: `unsupported WAV audioFormat=${fmt.audioFormat} (expected 1, linear PCM)`
+			};
+			if (fmt.bitsPerSample !== 16) return {
+				status: "invalid",
+				reason: `unsupported WAV bitsPerSample=${fmt.bitsPerSample} (expected 16)`
+			};
+		} else if (id === "data") {
+			if (fmt == null) return {
+				status: "invalid",
+				reason: "data chunk preceded fmt chunk"
+			};
+			return {
+				status: "parsed",
+				format: {
+					sampleRate: fmt.sampleRate,
+					channels: fmt.channels,
+					bitsPerSample: fmt.bitsPerSample
+				},
+				dataOffset: payloadStart
+			};
+		}
+		offset = payloadStart + size + (size & 1);
+	}
+	return { status: "need-more" };
+}
+function concatChunks(chunks) {
+	if (chunks.length === 1) return chunks[0];
+	let total = 0;
+	for (const c of chunks) total += c.byteLength;
+	const out = new Uint8Array(total);
+	let at = 0;
+	for (const c of chunks) {
+		out.set(c, at);
+		at += c.byteLength;
+	}
+	return out;
+}
+function resolveAudioContextCtor() {
+	if (typeof window === "undefined") return void 0;
+	return window.AudioContext ?? window.webkitAudioContext;
+}
+function detectStrategy(mimeType, override, pcmPrefixes) {
+	if (override === "pcm" || override === "element") return override;
+	const m = mimeType ?? "";
+	return m === "audio/pcm" || m === "audio/L16" || m.startsWith("audio/pcm;") || m.startsWith("audio/L16;") || m === "audio/wav" || m === "audio/wave" || m === "audio/x-wav" || m === "audio/vnd.wave" || (pcmPrefixes?.some((p) => m.startsWith(p)) ?? false) ? "pcm" : "element";
+}
+/**
+* Progressive audio playback for {@link AudioMedia} handles with a
+* uniform surface across PCM (streamed) and container
+* (`HTMLAudioElement`) strategies.
+*
+* See {@link useAudioPlayer} in the React binding for the full
+* behaviour spec; this Vue version exposes the same contract with
+* reactive refs in place of React state values.
+*
+* @param media   - Audio handle from `useAudio` (ref or getter).
+* @param options - Strategy overrides and PCM format hints.
+*/
+function useAudioPlayer(media, options) {
+	const sampleRate = options?.pcm?.sampleRate ?? DEFAULT_SAMPLE_RATE;
+	const channels = options?.pcm?.channels ?? DEFAULT_CHANNELS;
+	const pcmPrefixes = options?.pcmMimePrefixes;
+	const strategyOverride = options?.strategy ?? "auto";
+	const autoPlay = options?.autoPlay ?? false;
+	const status = (0, vue.ref)("idle");
+	const error = (0, vue.ref)(void 0);
+	const currentTime = (0, vue.ref)(0);
+	const duration = (0, vue.ref)(void 0);
+	const level = (0, vue.ref)(0);
+	const strategyRef = (0, vue.ref)("element");
+	let ctx = null;
+	let analyser = null;
+	let freqBuf = null;
+	let timeBuf = null;
+	let rafHandle = null;
+	let playStartCtxTime = 0;
+	let nextStartTime = 0;
+	let shouldPlay = false;
+	let pendingChunks = [];
+	const activeSources = /* @__PURE__ */ new Set();
+	let format = null;
+	let upstreamFinished = false;
+	let audioEl = null;
+	let elementSource = null;
+	let pendingResolve = null;
+	let pendingReject = null;
+	const resolvePending = () => {
+		const resolve = pendingResolve;
+		pendingResolve = null;
+		pendingReject = null;
+		resolve?.();
+	};
+	const rejectPending = (err) => {
+		const reject = pendingReject;
+		pendingResolve = null;
+		pendingReject = null;
+		reject?.(err);
+	};
+	(0, vue.watch)(() => status.value, (s) => {
+		if (s === "finished" || s === "paused" || s === "idle") resolvePending();
+		else if (s === "error") rejectPending(error.value ?? /* @__PURE__ */ new Error("playback error"));
+	});
+	const tickAnalyser = () => {
+		if (analyser == null) {
+			rafHandle = null;
+			return;
+		}
+		if (timeBuf != null) {
+			analyser.getByteTimeDomainData(timeBuf);
+			let sum = 0;
+			for (let i = 0; i < timeBuf.length; i += 1) {
+				const v = (timeBuf[i] - 128) / 128;
+				sum += v * v;
+			}
+			level.value = Math.sqrt(sum / timeBuf.length);
+		}
+		if (ctx != null && status.value === "playing") currentTime.value = ctx.currentTime - playStartCtxTime;
+		if (typeof window !== "undefined") rafHandle = window.requestAnimationFrame(tickAnalyser);
+	};
+	const startAnalyserLoop = () => {
+		if (rafHandle != null) return;
+		if (typeof window === "undefined") return;
+		rafHandle = window.requestAnimationFrame(tickAnalyser);
+	};
+	const stopAnalyserLoop = () => {
+		if (rafHandle == null) return;
+		if (typeof window !== "undefined") window.cancelAnimationFrame(rafHandle);
+		rafHandle = null;
+		level.value = 0;
+	};
+	const ensureAnalyser = (context) => {
+		if (analyser != null) return analyser;
+		const node = context.createAnalyser();
+		node.fftSize = ANALYSER_FFT_SIZE;
+		node.connect(context.destination);
+		analyser = node;
+		freqBuf = new Uint8Array(node.frequencyBinCount);
+		timeBuf = new Uint8Array(node.fftSize);
+		return node;
+	};
+	const ensureContextForPcm = () => {
+		if (ctx != null) return ctx;
+		if (format == null) return null;
+		const AudioCtx = resolveAudioContextCtor();
+		if (AudioCtx == null) {
+			error.value = /* @__PURE__ */ new Error("Web Audio API is not available in this environment");
+			status.value = "error";
+			return null;
+		}
+		const context = new AudioCtx({ sampleRate: format.sampleRate });
+		ctx = context;
+		nextStartTime = context.currentTime;
+		ensureAnalyser(context);
+		return context;
+	};
+	const ensureContextForElement = () => {
+		if (ctx != null) return ctx;
+		const AudioCtx = resolveAudioContextCtor();
+		if (AudioCtx == null) return null;
+		const context = new AudioCtx();
+		ctx = context;
+		ensureAnalyser(context);
+		return context;
+	};
+	const scheduleChunk = (context, bytes) => {
+		if (format == null || analyser == null) return;
+		const { sampleRate: bufSampleRate, channels: bufChannels } = format;
+		const sampleCount = Math.floor(bytes.byteLength / 2);
+		if (sampleCount === 0) return;
+		const framesPerChannel = Math.floor(sampleCount / bufChannels);
+		if (framesPerChannel === 0) return;
+		const buffer = context.createBuffer(bufChannels, framesPerChannel, bufSampleRate);
+		const view = new DataView(bytes.buffer, bytes.byteOffset, framesPerChannel * bufChannels * 2);
+		for (let channel = 0; channel < bufChannels; channel += 1) {
+			const channelData = buffer.getChannelData(channel);
+			for (let frame = 0; frame < framesPerChannel; frame += 1) {
+				const sampleOffset = (frame * bufChannels + channel) * 2;
+				const int = view.getInt16(sampleOffset, true);
+				channelData[frame] = int < 0 ? int / 32768 : int / 32767;
+			}
+		}
+		const source = context.createBufferSource();
+		source.buffer = buffer;
+		source.connect(analyser);
+		const now = context.currentTime;
+		const startAt = Math.max(now, nextStartTime);
+		source.start(startAt);
+		nextStartTime = startAt + buffer.duration;
+		activeSources.add(source);
+		source.onended = () => {
+			activeSources.delete(source);
+			if (activeSources.size === 0 && upstreamFinished && pendingChunks.length === 0) status.value = "finished";
+		};
+	};
+	const flushPendingPcm = () => {
+		if (!shouldPlay) return;
+		const context = ensureContextForPcm();
+		if (context == null) return;
+		if (context.state === "suspended") context.resume();
+		const chunks = pendingChunks;
+		pendingChunks = [];
+		for (const bytes of chunks) scheduleChunk(context, bytes);
+		if (chunks.length > 0 && status.value !== "playing") {
+			playStartCtxTime = context.currentTime;
+			currentTime.value = 0;
+			status.value = "playing";
+			startAnalyserLoop();
+		}
+	};
+	const play = () => {
+		if ((0, vue.toValue)(media) == null) return;
+		if (status.value === "error") return;
+		if (strategyRef.value === "pcm") {
+			shouldPlay = true;
+			if (status.value !== "playing") status.value = "buffering";
+			const context = ensureContextForPcm();
+			if (context != null && context.state === "suspended") context.resume();
+			flushPendingPcm();
+			return;
+		}
+		if (audioEl == null) {
+			shouldPlay = true;
+			status.value = "buffering";
+			return;
+		}
+		shouldPlay = true;
+		const context = ensureContextForElement();
+		if (context != null && context.state === "suspended") context.resume();
+		audioEl.play().catch((err) => {
+			error.value = err;
+			status.value = "error";
+		});
+	};
+	const pause = () => {
+		shouldPlay = false;
+		if (strategyRef.value === "pcm") {
+			if (ctx != null && ctx.state === "running") ctx.suspend();
+		} else audioEl?.pause();
+		if (status.value === "playing" || status.value === "buffering") status.value = "paused";
+	};
+	const stop = () => {
+		shouldPlay = false;
+		stopAnalyserLoop();
+		if (strategyRef.value === "pcm") {
+			for (const source of activeSources) try {
+				source.stop();
+			} catch {}
+			activeSources.clear();
+			pendingChunks = [];
+			nextStartTime = 0;
+		} else if (audioEl != null) {
+			audioEl.pause();
+			audioEl.currentTime = 0;
+		}
+		const context = ctx;
+		ctx = null;
+		analyser = null;
+		freqBuf = null;
+		timeBuf = null;
+		elementSource = null;
+		if (context != null) context.close();
+		currentTime.value = 0;
+		status.value = (0, vue.toValue)(media) == null ? "idle" : "paused";
+	};
+	const reset = () => {
+		stop();
+		error.value = void 0;
+		duration.value = void 0;
+		upstreamFinished = false;
+		status.value = "idle";
+	};
+	const toggle = () => {
+		if (status.value === "playing") pause();
+		else play();
+	};
+	const playToEnd = () => {
+		pendingResolve?.();
+		pendingResolve = null;
+		pendingReject = null;
+		return new Promise((resolve, reject) => {
+			pendingResolve = resolve;
+			pendingReject = reject;
+			play();
+		});
+	};
+	const seek = (seconds) => {
+		if (strategyRef.value !== "element") return;
+		if (audioEl == null) return;
+		audioEl.currentTime = seconds;
+		currentTime.value = seconds;
+	};
+	const getFrequencyData = () => {
+		if (analyser == null || freqBuf == null) return void 0;
+		analyser.getByteFrequencyData(freqBuf);
+		return freqBuf;
+	};
+	const getTimeDomainData = () => {
+		if (analyser == null || timeBuf == null) return void 0;
+		analyser.getByteTimeDomainData(timeBuf);
+		return timeBuf;
+	};
+	let detachPcm = null;
+	let detachElement = null;
+	const teardownBinding = () => {
+		detachPcm?.();
+		detachPcm = null;
+		detachElement?.();
+		detachElement = null;
+		const el = audioEl;
+		audioEl = null;
+		elementSource = null;
+		if (el != null) try {
+			el.pause();
+			el.removeAttribute("src");
+			el.load();
+		} catch {}
+	};
+	const bindPcm = (m) => {
+		error.value = void 0;
+		status.value = "buffering";
+		currentTime.value = 0;
+		duration.value = void 0;
+		upstreamFinished = false;
+		pendingChunks = [];
+		const mimeType = m.mimeType ?? "";
+		const isRawPcm = mimeType === "audio/pcm" || mimeType === "audio/L16" || mimeType.startsWith("audio/pcm;") || mimeType.startsWith("audio/L16;") || pcmPrefixes != null && pcmPrefixes.some((prefix) => mimeType.startsWith(prefix));
+		const isWav = mimeType === "audio/wav" || mimeType === "audio/wave" || mimeType === "audio/x-wav" || mimeType === "audio/vnd.wave";
+		if (isRawPcm) format = {
+			sampleRate,
+			channels,
+			bitsPerSample: 16
+		};
+		else if (isWav) format = null;
+		else {
+			error.value = /* @__PURE__ */ new Error(`useAudioPlayer: forced PCM strategy for unsupported mime ${JSON.stringify(mimeType)}`);
+			status.value = "error";
+			return () => {};
+		}
+		const wavHeaderChunks = [];
+		let wavHeaderParsed = !isWav;
+		let wavHeaderFailed = false;
+		const routeChunk = (bytes) => {
+			if (wavHeaderFailed) return;
+			if (wavHeaderParsed) {
+				pendingChunks.push(bytes);
+				if (shouldPlay) flushPendingPcm();
+				return;
+			}
+			wavHeaderChunks.push(bytes);
+			const combined = concatChunks(wavHeaderChunks);
+			const result = tryParseWavHeader(combined);
+			if (result.status === "need-more") return;
+			if (result.status === "invalid") {
+				wavHeaderFailed = true;
+				error.value = /* @__PURE__ */ new Error(`useAudioPlayer: invalid WAV stream: ${result.reason}`);
+				status.value = "error";
+				return;
+			}
+			format = result.format;
+			wavHeaderParsed = true;
+			wavHeaderChunks.length = 0;
+			const tail = combined.subarray(result.dataOffset);
+			if (tail.byteLength > 0) {
+				pendingChunks.push(tail);
+				if (shouldPlay) flushPendingPcm();
+			}
+		};
+		if (autoPlay) shouldPlay = true;
+		return attachToPump(m, (event) => {
+			switch (event.type) {
+				case "chunk":
+					routeChunk(event.bytes);
+					break;
+				case "finished":
+					upstreamFinished = true;
+					if (pendingChunks.length === 0 && activeSources.size === 0) status.value = "finished";
+					break;
+				case "error":
+					error.value = event.error;
+					status.value = "error";
+					break;
+			}
+		});
+	};
+	const bindElement = (m) => {
+		if (typeof window === "undefined") return () => {};
+		error.value = void 0;
+		status.value = "buffering";
+		currentTime.value = 0;
+		duration.value = void 0;
+		let cancelled = false;
+		m.objectURL.then((resolved) => {
+			if (cancelled) return;
+			audioEl = new Audio(resolved);
+			audioEl.preload = "auto";
+			const el = audioEl;
+			const onPlay = () => {
+				if (status.value === "error") return;
+				const context = ensureContextForElement();
+				if (context != null && elementSource == null && el != null) try {
+					const src = context.createMediaElementSource(el);
+					src.connect(analyser);
+					elementSource = src;
+				} catch {}
+				playStartCtxTime = 0;
+				currentTime.value = el?.currentTime ?? 0;
+				status.value = "playing";
+				startAnalyserLoop();
+			};
+			const onPause = () => {
+				if (el != null && el.ended) return;
+				if (status.value === "playing") status.value = "paused";
+			};
+			const onEnded = () => {
+				status.value = "finished";
+			};
+			const onTimeUpdate = () => {
+				if (el != null) currentTime.value = el.currentTime;
+			};
+			const onLoadedMetadata = () => {
+				if (el != null && Number.isFinite(el.duration)) duration.value = el.duration;
+			};
+			const onError = () => {
+				error.value = /* @__PURE__ */ new Error("HTMLAudioElement error");
+				status.value = "error";
+			};
+			el.addEventListener("play", onPlay);
+			el.addEventListener("pause", onPause);
+			el.addEventListener("ended", onEnded);
+			el.addEventListener("timeupdate", onTimeUpdate);
+			el.addEventListener("loadedmetadata", onLoadedMetadata);
+			el.addEventListener("error", onError);
+			if (shouldPlay || autoPlay) el.play().catch((err) => {
+				error.value = err;
+				status.value = "error";
+			});
+			else status.value = "paused";
+		}, () => {
+			if (!cancelled) {
+				error.value = /* @__PURE__ */ new Error("media failed to materialise");
+				status.value = "error";
+			}
+		});
+		return () => {
+			cancelled = true;
+			try {
+				m.revoke();
+			} catch {}
+		};
+	};
+	(0, vue.watch)(() => (0, vue.toValue)(media), (m) => {
+		teardownBinding();
+		if (m == null) {
+			status.value = "idle";
+			error.value = void 0;
+			currentTime.value = 0;
+			duration.value = void 0;
+			level.value = 0;
+			upstreamFinished = false;
+			return;
+		}
+		strategyRef.value = detectStrategy(m.mimeType, strategyOverride, pcmPrefixes);
+		if (m.error != null) {
+			error.value = new Error(m.error.message);
+			status.value = "error";
+			return;
+		}
+		if (strategyRef.value === "pcm") detachPcm = bindPcm(m) ?? null;
+		else detachElement = bindElement(m);
+	}, { immediate: true });
+	(0, vue.onScopeDispose)(() => {
+		teardownBinding();
+		stop();
+	});
+	return {
+		status,
+		strategy: strategyRef,
+		play,
+		pause,
+		stop,
+		toggle,
+		reset,
+		playToEnd,
+		currentTime,
+		duration,
+		seek,
+		level,
+		getFrequencyData,
+		getTimeDomainData,
+		error
+	};
+}
+//#endregion
+exports.useAudioPlayer = useAudioPlayer;
+
+//# sourceMappingURL=use-audio-player.cjs.map