@flowingspring/dsh-voco 0.2.0

package/lib/plugins/voice-web.js

@@ -0,0 +1,267 @@
+import { VoiceCommandCallId, VoiceTaskId } from "./voice.js";
+import { randomUUID } from "node:crypto";
+import z from "@deepseek-ai/schemastery";
+import { SessionId } from "@deepseek-ai/dsh-session";
+import WebSocket, { WebSocketServer } from "ws";
+//#region ../voice-web/src/loopback-hostname.ts
+/**
+* Browser-safe, zero-dependency loopback classification shared by the `/api`
+* Host fence and the package's `ctx.connection` state. The predicate stays
+* package-internal; client plugins consume the derived state through Cordis.
+*/
+/**
+* Whether a normalized URL hostname names the local loopback authority.
+* @param hostname - WHATWG URL hostname (IPv6 literals retain brackets).
+* @returns true for localhost, IPv6 loopback, or any IPv4 address in 127/8.
+*/
+function isLoopbackHostname(hostname) {
+	if (hostname === "localhost" || hostname === "[::1]") return true;
+	const parts = hostname.split(".");
+	return parts.length === 4 && parts[0] === "127" && parts.every((part) => /^\d{1,3}$/.test(part) && Number(part) <= 255);
+}
+//#endregion
+//#region ../voice-web/src/api-request-trust.ts
+function header(headers, name) {
+	if (headers instanceof Headers) return headers.get(name) ?? void 0;
+	const value = headers[name];
+	return typeof value === "string" ? value : void 0;
+}
+/** Normalized URL of a Host-header authority (hostname lowercased, default port stripped, IPv6 bracketed), or undefined when unparsable. */
+function parseAuthority(authority) {
+	try {
+		return new URL(`http://${authority}`);
+	} catch {
+		return;
+	}
+}
+/**
+* Assert one configured `trustedHosts` entry is a bare authority (`host` or
+* `host:port`) in canonical form: it must survive WHATWG parsing unchanged
+* (case aside). Anything parsing would silently rewrite is refused as a typo
+* that must fail the load loudly instead of being ignored until requests 403
+* or quietly changing the grant: URL parts beyond the authority
+* (`harness.internal/path`, `user@harness.internal` — which would authorize
+* the embedded hostname), stripped whitespace, a dangling colon or
+* zero-padded port (which would broaden an intended exact-port grant to every
+* port), and non-canonical host spellings (`0x7f.0.0.1`, percent-encoding,
+* unbracketed IPv6; IDN hosts are declared in punycode, the form the wire
+* carries).
+* @param entry - the configured value, verbatim.
+*/
+function assertTrustedAuthority(entry) {
+	const entryUrl = parseAuthority(entry);
+	if (entryUrl !== void 0 && canonicalAuthority(entry, entryUrl) === entry.toLowerCase()) return;
+	throw new Error(`client-connection: trustedHosts entry ${JSON.stringify(entry)} is not a bare host[:port] authority`);
+}
+/**
+* Canonical form of a parsed authority: `hostname` when no port was written,
+* else `hostname:port`. The port is judged from URL parses under both special
+* schemes (their default ports differ, so `:80` and `:443` still count as
+* explicit), never from the raw string, where WHATWG trimming would misread
+* shapes like `host:port ` as port-less.
+*/
+function canonicalAuthority(entry, entryUrl) {
+	const port = entryUrl.port !== "" ? entryUrl.port : new URL(`https://${entry}`).port;
+	return port === "" ? entryUrl.hostname : `${entryUrl.hostname}:${port}`;
+}
+/**
+* Whether the request authority matches a `trustedHosts` entry. An entry with
+* an explicit port matches that exact authority; a port-less entry matches the
+* hostname on any port (the shape the CLI derives for IP-literal LAN serving,
+* where the bound port may be OS-assigned). Both sides compare through WHATWG
+* normalization, so case and a redundant `:80` never decide trust.
+*/
+function isTrustedAuthority(hostUrl, trustedHosts) {
+	return trustedHosts.some((entry) => {
+		const entryUrl = parseAuthority(entry);
+		if (entryUrl === void 0) return false;
+		return canonicalAuthority(entry, entryUrl) === entryUrl.hostname ? entryUrl.hostname === hostUrl.hostname : entryUrl.host === hostUrl.host;
+	});
+}
+/**
+* Decide whether one /api request may reach the RPC bridge.
+* @param request - Node HTTP or Fetch request facts (headers).
+* @param trustedHosts - non-loopback authorities this deployment serves: exact `host:port`, or port-less `host` matching any port.
+* @returns true when the Host is ours (loopback or trusted) and any attached browser markers are same-origin.
+*/
+function isTrustedApiRequest(request, trustedHosts) {
+	const host = header(request.headers, "host");
+	if (host === void 0) return false;
+	const hostUrl = parseAuthority(host);
+	if (hostUrl === void 0) return false;
+	if (!isLoopbackHostname(hostUrl.hostname) && !isTrustedAuthority(hostUrl, trustedHosts)) return false;
+	if (header(request.headers, "sec-fetch-site") === "cross-site") return false;
+	const origin = header(request.headers, "origin");
+	if (origin === void 0) return true;
+	try {
+		return new URL(origin).host === hostUrl.host;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region ../voice-web/src/index.ts
+/** Dedicated browser WebSocket carrier for realtime voice audio and events. @module @flowingspring/dsh-voice-web */
+const name = "voice-web";
+const inject = ["voice", "webServer"];
+/** Dedicated browser voice upgrade pathname. */
+const VOICE_PATH = "/voice";
+const Config = z.object({
+	trustedHosts: z.array(String).default([]),
+	maxAudioFrameBytes: z.natural().min(1).default(65536)
+});
+/** Register the `/voice` upgrade route. @param ctx - web and voice context. @param config - trust and frame limits. */
+function apply(ctx, config = {}) {
+	const trustedHosts = config.trustedHosts ?? [];
+	for (const authority of trustedHosts) assertTrustedAuthority(authority);
+	const maxAudioFrameBytes = config.maxAudioFrameBytes ?? 65536;
+	const server = new WebSocketServer({
+		noServer: true,
+		maxPayload: maxAudioFrameBytes
+	});
+	ctx.effect(() => ctx.webServer.registerUpgrade({
+		path: VOICE_PATH,
+		handler: (request, socket, head) => {
+			if (!isTrustedApiRequest(request, trustedHosts)) {
+				socket.end("HTTP/1.1 403 Forbidden\r\nConnection: close\r\nContent-Length: 9\r\n\r\nforbidden");
+				return;
+			}
+			server.handleUpgrade(request, socket, head, (websocket) => {
+				/* v8 ignore next -- node:http always sets url on server upgrade requests */
+				attach(ctx, websocket, request.url ?? "/voice");
+			});
+		}
+	}), "voice-web route");
+	ctx.effect(() => async () => {
+		for (const socket of server.clients) socket.terminate();
+		await new Promise((resolve, reject) => {
+			server.close((error) => {
+				if (error === void 0) resolve();
+				else reject(error);
+			});
+		});
+	}, "voice-web sockets");
+}
+async function attach(ctx, socket, rawUrl) {
+	const voice = ctx.voice;
+	let voiceId;
+	let unsubscribe;
+	const state = {
+		closed: false,
+		finalClose: false
+	};
+	const finalClose = (id) => {
+		voice.close(id).catch((error) => {
+			ctx.logger.warn(error instanceof Error ? error : new Error(String(error)));
+		});
+	};
+	socket.once("close", () => {
+		state.closed = true;
+		unsubscribe?.();
+		if (voiceId === void 0) return;
+		if (state.finalClose) finalClose(voiceId);
+		else voice.detach(voiceId);
+	});
+	socket.on("error", (error) => {
+		/* v8 ignore next -- other WebSocket errors are transport loss and retain the provider for reconnect */
+		if (error.code === "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH") state.finalClose = true;
+	});
+	try {
+		const value = new URL(rawUrl, "http://voice.local").searchParams.get("sessionId");
+		if (value === null || value === "") {
+			state.finalClose = true;
+			socket.close(1008, "sessionId is required");
+			return;
+		}
+		const session = await voice.open(SessionId(value));
+		voiceId = session.id;
+		if (state.closed) {
+			await voice.close(session.id);
+			return;
+		}
+		unsubscribe = voice.subscribe(session.id, (event) => {
+			sendEvent(socket, event);
+			if (event.type === "closed") {
+				state.finalClose = true;
+				socket.close(1011, "voice provider closed");
+			}
+		});
+		socket.send(JSON.stringify({
+			type: "ready",
+			voiceSessionId: session.id,
+			audio: session.audio,
+			interactionMode: session.interactionMode
+		}));
+		socket.on("message", (data, isBinary) => {
+			const frame = data;
+			if (isBinary) {
+				voice.appendAudio(session.id, frame);
+				return;
+			}
+			let control;
+			const text = frame.toString("utf8");
+			try {
+				control = JSON.parse(text);
+			} catch {
+				state.finalClose = true;
+				socket.close(1008, "invalid control frame");
+				return;
+			}
+			if (control === null || typeof control !== "object") {
+				state.finalClose = true;
+				socket.close(1008, "invalid control frame");
+				return;
+			}
+			const type = control.type;
+			if (type === "audio.commit") voice.commitAudio(session.id);
+			else if (type === "response.interrupt") voice.interruptResponse(session.id);
+			else if (type === "playback.ended") voice.playbackEnded(session.id);
+			else if (type === "task.cancel") {
+				const taskId = control.taskId;
+				if (typeof taskId !== "string" || taskId === "") {
+					state.finalClose = true;
+					socket.close(1008, "taskId is required");
+					return;
+				}
+				voice.submitTaskCommand(session.id, {
+					id: VoiceCommandCallId(`browser:${randomUUID()}`),
+					command: {
+						type: "cancel_task",
+						taskId: VoiceTaskId(taskId)
+					}
+				});
+			} else if (type === "text.submit") {
+				const submitted = control.text;
+				if (typeof submitted !== "string" || submitted.trim() === "") {
+					state.finalClose = true;
+					socket.close(1008, "text is required");
+					return;
+				}
+				voice.submitText(session.id, submitted);
+			} else if (type === "session.close") {
+				state.finalClose = true;
+				unsubscribe?.();
+				finalClose(session.id);
+				socket.close(1e3, "voice session closed");
+			} else {
+				state.finalClose = true;
+				socket.close(1008, "unknown control frame");
+			}
+		});
+	} catch (error) {
+		state.finalClose = true;
+		if (socket.readyState === WebSocket.OPEN) socket.send(JSON.stringify({
+			type: "error",
+			message: String(error)
+		}));
+		socket.close(1011, "voice setup failed");
+	}
+}
+function sendEvent(socket, event) {
+	/* v8 ignore next -- the close-race guard cannot be scheduled deterministically */
+	if (socket.readyState !== WebSocket.OPEN) return;
+	if (event.type === "output_audio.delta") socket.send(event.audio, { binary: true });
+	else socket.send(JSON.stringify(event));
+}
+//#endregion
+export { Config, VOICE_PATH, apply, inject, name };

package/lib/plugins/voice.js

@@ -0,0 +1,401 @@
+import { randomUUID } from "node:crypto";
+import { Service } from "@deepseek-ai/cordis";
+import z from "@deepseek-ai/schemastery";
+//#region ../voice/src/types.ts
+/**
+* Brand a raw id as a voice-session identity.
+* @param value - raw identity.
+* @returns branded identity.
+*/
+function VoiceSessionId(value) {
+	return value;
+}
+/**
+* Brand a raw id as a voice-task identity.
+* @param value - raw identity.
+* @returns branded identity.
+*/
+function VoiceTaskId(value) {
+	return value;
+}
+/**
+* Brand a raw id as a voice-utterance identity.
+* @param value - provider or locally minted utterance identity.
+* @returns branded identity.
+*/
+function VoiceUtteranceId(value) {
+	return value;
+}
+/**
+* Brand a raw id as a voice-response identity.
+* @param value - provider response identity.
+* @returns branded identity.
+*/
+function VoiceResponseId(value) {
+	return value;
+}
+/**
+* Brand a raw id as a frontend command-call identity.
+* @param value - provider call identity.
+* @returns branded identity.
+*/
+function VoiceCommandCallId(value) {
+	return value;
+}
+/**
+* Brand a raw id as a backend voice-message identity.
+* @param value - raw identity.
+* @returns branded identity.
+*/
+function VoiceTaskMessageId(value) {
+	return value;
+}
+//#endregion
+//#region ../voice/src/index.ts
+/** Provider-neutral realtime voice session capability seam. @module @flowingspring/dsh-voice */
+/** Provider registry and connected-session coordinator. */
+var VoiceRuntime = class extends Service {
+	static Config = z.object({
+		provider: z.string(),
+		maxCommandCalls: z.natural().min(1).default(256),
+		reconnectGraceMs: z.natural().min(1).default(6e4)
+	});
+	providers = /* @__PURE__ */ new Map();
+	sessions = /* @__PURE__ */ new Map();
+	memory = { source: void 0 };
+	configuredProvider;
+	maxCommandCalls;
+	reconnectGraceMs;
+	constructor(ctx, config = {}) {
+		super(ctx, "voice");
+		this.configuredProvider = config.provider;
+		this.maxCommandCalls = config.maxCommandCalls ?? 256;
+		this.reconnectGraceMs = config.reconnectGraceMs ?? 6e4;
+		ctx.effect(() => async () => {
+			const settled = await Promise.allSettled([...this.sessions.keys()].map((id) => this.close(id)));
+			const failures = [];
+			for (const result of settled) if (result.status === "rejected") failures.push(result.reason);
+			if (failures.length > 0) throw new AggregateError(failures, "failed to close voice provider sessions");
+		}, "voice provider sessions");
+	}
+	/**
+	* Register one provider.
+	* @param provider - provider implementation.
+	* @returns disposer removing it.
+	*/
+	registerProvider(provider) {
+		if (this.providers.has(provider.id)) throw new Error(`voice provider "${provider.id}" is already registered`);
+		this.providers.set(provider.id, provider);
+		return () => {
+			this.providers.delete(provider.id);
+		};
+	}
+	/**
+	* Register the sole durable conversation-memory source.
+	* @param source - loader keyed by the durable source Agent session.
+	* @returns disposer removing it when still current.
+	*/
+	registerMemorySource(source) {
+		if (this.memory.source !== void 0) throw new Error("voice conversation memory source is already registered");
+		this.memory.source = source;
+		return () => {
+			if (this.memory.source === source) this.memory.source = void 0;
+		};
+	}
+	/**
+	* Open or reattach a voice transport for an Agent session.
+	* @param agentSessionId - durable Agent identity.
+	* @returns connected session metadata.
+	*/
+	async open(agentSessionId) {
+		const detached = [...this.sessions.values()].find((live) => !live.attached && live.info.agentSessionId === agentSessionId);
+		if (detached !== void 0) {
+			clearTimeout(detached.detachTimer);
+			delete detached.detachTimer;
+			detached.attached = true;
+			this.ctx.emit("voice/session-opened", detached.info);
+			return detached.info;
+		}
+		const id = VoiceSessionId(randomUUID());
+		const provider = this.resolveProvider();
+		const memory = await this.memory.source?.(agentSessionId);
+		const holder = {};
+		const connected = await provider.connect({
+			voiceSessionId: id,
+			agentSessionId,
+			...memory !== void 0 && memory.items.length > 0 ? { memory } : {},
+			emit: (event) => {
+				const live = holder.live;
+				if (live === void 0 || this.sessions.get(id) !== live) return;
+				this.acceptProviderEvent(live, event);
+			}
+		});
+		const info = {
+			id,
+			agentSessionId,
+			audio: connected.audio,
+			interactionMode: connected.interactionMode
+		};
+		const live = {
+			info,
+			provider: connected,
+			listeners: /* @__PURE__ */ new Set(),
+			commands: /* @__PURE__ */ new Map(),
+			attached: true
+		};
+		holder.live = live;
+		this.sessions.set(id, live);
+		this.ctx.emit("voice/session-opened", info);
+		return info;
+	}
+	/**
+	* Subscribe to one session's events; a failing listener is logged without starving later listeners.
+	* @param id - voice session.
+	* @param listener - event receiver.
+	* @returns disposer.
+	*/
+	subscribe(id, listener) {
+		const live = this.requireAttachedSession(id);
+		live.listeners.add(listener);
+		return () => {
+			live.listeners.delete(listener);
+		};
+	}
+	/**
+	* Forward microphone PCM.
+	* @param id - voice session.
+	* @param audio - PCM bytes.
+	*/
+	appendAudio(id, audio) {
+		this.requireAttachedSession(id).provider.appendAudio(audio);
+	}
+	/**
+	* Commit current microphone input.
+	* @param id - voice session.
+	*/
+	commitAudio(id) {
+		this.requireAttachedSession(id).provider.commitAudio();
+	}
+	/**
+	* Cancel current provider speech.
+	* @param id - voice session.
+	*/
+	interruptResponse(id) {
+		this.requireAttachedSession(id).provider.interruptResponse();
+	}
+	/**
+	* Report local playback completion.
+	* @param id - voice session.
+	*/
+	playbackEnded(id) {
+		this.requireAttachedSession(id).provider.playbackEnded();
+	}
+	/**
+	* Append model-independent task state.
+	* @param id - voice session.
+	* @param event - observation.
+	*/
+	appendTaskObservation(id, event) {
+		const live = this.requireAttachedSession(id);
+		live.provider.appendTaskObservation(event);
+		this.publish(live, {
+			type: "task.observation",
+			observation: event
+		});
+	}
+	/** Queue one already-rewritten speech fragment for the attached provider. */
+	appendSpeechText(id, text) {
+		const provider = this.requireAttachedSession(id).provider;
+		if (provider.appendSpeechText === void 0) return false;
+		provider.appendSpeechText(text);
+		return true;
+	}
+	/** Whether the attached provider supports independent speech fragments. */
+	supportsSpeechText(id) {
+		return this.requireAttachedSession(id).provider.appendSpeechText !== void 0;
+	}
+	/**
+	* Ask the provider to speak pending observations.
+	* @param id - voice session.
+	* @param policy - response policy.
+	*/
+	requestResponse(id, policy) {
+		this.requireAttachedSession(id).provider.requestResponse(policy);
+	}
+	/**
+	* Complete one admitted frontend command exactly once.
+	* @param id - voice session.
+	* @param callId - provider command call.
+	* @param result - typed bridge result.
+	*/
+	completeTaskCommand(id, callId, result) {
+		const live = this.requireSession(id);
+		const record = live.commands.get(callId);
+		if (record === void 0) throw new Error(`voice command call "${callId}" is not pending`);
+		if (record.result !== void 0) throw new Error(`voice command call "${callId}" is already completed`);
+		live.provider.completeTaskCommand(callId, result);
+		record.result = result;
+	}
+	/** Submit one validated command from a non-provider frontend control. */
+	submitTaskCommand(id, call) {
+		this.acceptTaskCommand(this.requireAttachedSession(id), call);
+	}
+	/** Route browser-typed text through the same transcript and task path as recognized speech. */
+	submitText(id, text) {
+		const value = text.trim();
+		if (value === "") throw new Error("voice text submission requires non-empty text");
+		const live = this.requireAttachedSession(id);
+		const utteranceId = VoiceUtteranceId(`typed:${randomUUID()}`);
+		live.provider.interruptResponse();
+		this.publish(live, {
+			type: "transcription.started",
+			utteranceId
+		});
+		this.publish(live, {
+			type: "transcription.completed",
+			utteranceId,
+			text: value
+		});
+		this.acceptTaskCommand(live, {
+			id: VoiceCommandCallId(`typed:${randomUUID()}`),
+			command: {
+				type: "route_transcription",
+				input: value
+			}
+		});
+	}
+	/**
+	* Detach the browser while retaining the provider conversation for bounded reconnection.
+	* @param id - voice session.
+	*/
+	detach(id) {
+		const live = this.sessions.get(id);
+		if (live === void 0 || !live.attached) return;
+		live.attached = false;
+		live.listeners.clear();
+		this.ctx.emit("voice/session-detached", live.info);
+		try {
+			live.provider.interruptResponse();
+		} catch (error) {
+			this.ctx.logger.warn(error instanceof Error ? error : new Error(String(error)));
+		}
+		live.detachTimer = setTimeout(() => {
+			delete live.detachTimer;
+			this.close(id).catch((error) => {
+				this.ctx.logger.warn(error instanceof Error ? error : new Error(String(error)));
+			});
+		}, this.reconnectGraceMs);
+		live.detachTimer.unref();
+	}
+	/**
+	* Final-close one provider conversation without disposing its Agent.
+	* @param id - voice session.
+	*/
+	async close(id) {
+		const live = this.sessions.get(id);
+		if (live === void 0) return;
+		this.sessions.delete(id);
+		if (live.detachTimer !== void 0) clearTimeout(live.detachTimer);
+		live.attached = false;
+		live.listeners.clear();
+		this.ctx.emit("voice/session-closed", live.info);
+		await live.provider.close();
+	}
+	publish(live, event) {
+		this.ctx.emit("voice/session-event", live.info, event);
+		for (const listener of live.listeners) try {
+			listener(event);
+		} catch (error) {
+			this.ctx.logger.warn(error instanceof Error ? error : new Error(String(error)));
+		}
+	}
+	acceptProviderEvent(live, event) {
+		if (event.type === "closed") {
+			this.publish(live, event);
+			this.close(live.info.id).catch((error) => {
+				this.ctx.logger.warn(error instanceof Error ? error : new Error(String(error)));
+			});
+			return;
+		}
+		if (!live.attached && event.type !== "task.command") return;
+		if (event.type !== "task.command") {
+			this.publish(live, event);
+			return;
+		}
+		this.acceptTaskCommand(live, event.call);
+	}
+	acceptTaskCommand(live, call) {
+		const fingerprint = commandFingerprint(call);
+		const existing = live.commands.get(call.id);
+		if (existing === void 0) {
+			if (live.commands.size >= this.maxCommandCalls) {
+				live.provider.completeTaskCommand(call.id, {
+					kind: "rejected",
+					code: "capacity_exceeded",
+					message: `voice session already tracks ${String(this.maxCommandCalls)} command calls`
+				});
+				return;
+			}
+			live.commands.set(call.id, { fingerprint });
+			this.publish(live, {
+				type: "task.command",
+				call
+			});
+			return;
+		}
+		if (existing.fingerprint !== fingerprint) {
+			this.publish(live, {
+				type: "error",
+				message: `voice command call "${call.id}" was reused with different arguments`
+			});
+			return;
+		}
+		if (existing.result !== void 0) live.provider.completeTaskCommand(call.id, existing.result);
+	}
+	requireSession(id) {
+		const live = this.sessions.get(id);
+		if (live === void 0) throw new Error(`voice session "${id}" is not open`);
+		return live;
+	}
+	requireAttachedSession(id) {
+		const live = this.requireSession(id);
+		if (!live.attached) throw new Error(`voice session "${id}" is detached`);
+		return live;
+	}
+	resolveProvider() {
+		if (this.configuredProvider !== void 0) {
+			const provider = this.providers.get(this.configuredProvider);
+			if (provider === void 0) throw new Error(`configured voice provider "${this.configuredProvider}" is not registered`);
+			if (!provider.available()) throw new Error(`configured voice provider "${this.configuredProvider}" is unavailable`);
+			return provider;
+		}
+		const available = [...this.providers.values()].filter((provider) => provider.available());
+		if (available.length !== 1) throw new Error(available.length === 0 ? "no usable voice provider is registered" : "multiple usable voice providers are registered; configure one explicitly");
+		return available[0];
+	}
+};
+function commandFingerprint(call) {
+	const command = call.command;
+	switch (command.type) {
+		case "route_transcription": return JSON.stringify([command.type, command.input]);
+		case "realtime_delegation": return JSON.stringify([
+			command.type,
+			command.input,
+			command.transcriptDelta
+		]);
+		case "send_task_message": return JSON.stringify([
+			command.type,
+			command.taskId,
+			command.message
+		]);
+		case "cancel_task": return JSON.stringify([command.type, command.taskId]);
+		/* v8 ignore next -- closed-union exhaustiveness guard */
+		default: return assertNever(command);
+	}
+}
+/* v8 ignore next -- only reachable through the closed-union guard */
+function assertNever(value) {
+	throw new Error(`unexpected task command: ${JSON.stringify(value)}`);
+}
+//#endregion
+export { VoiceCommandCallId, VoiceResponseId, VoiceRuntime, VoiceRuntime as default, VoiceSessionId, VoiceTaskId, VoiceTaskMessageId, VoiceUtteranceId };

package/lib/types/index.d.ts

@@ -0,0 +1,4 @@
+/** Voice profile patch package. @module @flowingspring/dsh-voco */
+/** Runtime no-op; the package manifest exposes the patch layer. */
+export declare function apply(): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/invariant.d.ts

@@ -0,0 +1,7 @@
+/** Package invariant companion. @module @flowingspring/dsh-voco/invariant */
+import type { Context } from '@deepseek-ai/cordis';
+export declare const name = "voco-invariant";
+export declare const inject: string[];
+/** Register invariant ownership. @param ctx - runtime context. @returns disposer. */
+export declare const apply: (ctx: Context) => Promise<() => void>;
+//# sourceMappingURL=invariant.d.ts.map