dsh-realtime-audio-ws 0.2.2 → 0.2.3

package/lib/client/index.js

@@ -24,7 +24,7 @@
  * actually been read, rather than shipping a capture path that a policy might silently kill.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.INJECTED_KEY = exports.GLOBAL_KEY = exports.MAX_BACKLOG_SECONDS = exports.CAPTURE_BUFFER = exports.SAMPLE_RATE = exports.DEFAULT_PATH = exports.inject = exports.name = void 0;
+exports.STRIP_ELEMENT_ID = exports.INJECTED_KEY = exports.GLOBAL_KEY = exports.MAX_BACKLOG_SECONDS = exports.CAPTURE_BUFFER = exports.SAMPLE_RATE = exports.DEFAULT_PATH = exports.inject = exports.name = void 0;
 exports.socketUrl = socketUrl;
 exports.pageAuthority = pageAuthority;
 exports.withToken = withToken;
@@ -32,6 +32,9 @@ exports.pcm16FromFloat32 = pcm16FromFloat32;
 exports.float32FromPcm16 = float32FromPcm16;
 exports.defaultDeps = defaultDeps;
 exports.createAudioClient = createAudioClient;
+exports.stripRoot = stripRoot;
+exports.renderStrip = renderStrip;
+exports.mountStrip = mountStrip;
 exports.apply = apply;
 /** Browser-side plugin name. */
 exports.name = 'realtime-audio-client';
@@ -166,12 +169,20 @@ function createAudioClient(deps) {
     let processor;
     let silence;
     let playsAt = 0;
+    /** The control request waiting for its reply, if any. The host answers one frame with one frame. */
+    let pending;
+    /** The tail of the request chain, so two frames are never in flight at once. */
+    let chain = Promise.resolve();
     const fail = (reason) => {
         current = { kind: 'failed', reason };
         return current;
     };
     /** Release everything held. Idempotent, because stop, an error and a close all reach it. */
     const release = () => {
+        // A request whose socket is going away must fail rather than hang: the panel disables half of itself
+        // while one is in flight, and a promise that never settles would leave it disabled for ever.
+        pending?.reject(new Error('the audio socket closed before the host answered'));
+        pending = undefined;
         socket?.close();
         socket = undefined;
         processor?.disconnect();
@@ -272,8 +283,26 @@ function createAudioClient(deps) {
         socket = opened;
         opened.binaryType = 'arraybuffer';
         opened.onmessage = (event) => {
-            if (event.data instanceof ArrayBuffer)
+            // Binary frames are audio; a string is the answer to a control frame. The frame's own type is what
+            // tells them apart, which is why the control channel cost this path nothing.
+            if (event.data instanceof ArrayBuffer) {
                 play(new Uint8Array(event.data));
+                return;
+            }
+            if (typeof event.data !== 'string')
+                return;
+            const waiting = pending;
+            pending = undefined;
+            if (waiting === undefined)
+                return;
+            try {
+                waiting.resolve(JSON.parse(event.data));
+            }
+            catch {
+                // A reply that is not JSON is a host fault, and the caller has to hear about it rather than be left
+                // waiting: the same rule the channel itself follows, one side out.
+                waiting.reject(new Error('the host answered a control frame with something that is not a reply'));
+            }
         };
         opened.onclose = () => {
             release();
@@ -284,23 +313,329 @@ function createAudioClient(deps) {
             opened.onerror = () => { resolve(fail('the host refused the audio socket')); };
         });
     };
-    return { start, stop, state: () => current };
+    /**
+     * Send one frame and wait for its reply.
+     *
+     * The socket is looked up at the moment of use rather than closed over, so a request made after a
+     * reconnect goes out on the socket that exists now — the same rule every other live value in this
+     * project follows.
+     * @param frame - the control frame.
+     * @returns the parsed reply.
+     */
+    const sendFrame = (frame) => {
+        const current = socket;
+        if (current === undefined) {
+            return Promise.reject(new Error('not connected: connect the microphone first'));
+        }
+        return new Promise((resolve, reject) => {
+            pending = { resolve, reject };
+            current.send(frame);
+        });
+    };
+    const request = (frame) => {
+        // Chained, not concurrent: the host answers in arrival order, and a client that pipelined would be
+        // pairing replies with frames by guesswork. The chain is kept alive across a failure, because one
+        // refused frame must not silently stop every frame behind it.
+        const next = chain.then(() => sendFrame(frame));
+        chain = next.catch(() => undefined);
+        return next;
+    };
+    return { start, stop, state: () => current, request };
+}
+// ---- the strip: the panel this plugin puts in the app ---------------------------------------------------
+/** The element the injected markup provides. Duplicated in the host half, which mints the row. */
+exports.STRIP_ELEMENT_ID = 'dsh-realtime-strip';
+/**
+ * Where the injected markup puts the panel, or `null` when this page does not carry it.
+ * @param scope - the page scope, injectable so both cases are testable without a DOM.
+ * @returns the panel's element, or `null`.
+ */
+function stripRoot(scope) {
+    return scope.document?.getElementById(exports.STRIP_ELEMENT_ID) ?? null;
+}
+/**
+ * Escape text for an element's body and for a quoted attribute at once.
+ *
+ * One function rather than two because the two contexts differ only in which characters break out, and
+ * every value a panel renders came from a plugin's own configuration — a session id, a model name, or
+ * `instructions` somebody typed.
+ * @param text - the text to escape.
+ * @returns the text, safe in either position.
+ */
+function escapeHtml(text) {
+    return text
+        .replaceAll('&', '&')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;')
+        .replaceAll('"', '&quot;');
+}
+/**
+ * Show one value as text.
+ * @param value - a setting's value as `status` reported it.
+ * @returns the text to render.
+ */
+function show(value) {
+    if (value === undefined || value === null)
+        return '—';
+    return typeof value === 'string' ? value : JSON.stringify(value);
+}
+/**
+ * Render the whole panel.
+ *
+ * A pure function of the state, because that is what makes the panel testable at all: the injected script
+ * is three lines and the DOM is one assignment, so everything worth checking lives here.
+ * @param state - what the panel is showing.
+ * @returns the markup for the panel's element.
+ */
+function renderStrip(state) {
+    const reply = state.reply;
+    const lines = [`<p data-dsh-strip-voice>${escapeHtml(summariseVoice(reply, state.audio))}</p>`];
+    if (reply !== null)
+        lines.push(`<p data-dsh-strip-route>${escapeHtml(summariseRoute(reply))}</p>`);
+    if (state.notice !== '')
+        lines.push(`<p data-dsh-strip-notice>${escapeHtml(state.notice)}</p>`);
+    lines.push(`<p data-dsh-strip-buttons>${buttons(state.audio)}</p>`);
+    // Restart-bound settings are omitted rather than shown read-only: the gate says no control at all, and a
+    // row that cannot be changed is a row a reader will try to change.
+    const settings = (reply?.settings ?? []).filter(entry => entry.scope !== 'restart');
+    lines.push(settings.length === 0
+        ? '<p data-dsh-strip-empty>no settings to show</p>'
+        : `<ul>${settings.map(entry => settingRow(entry, state.notes)).join('')}</ul>`);
+    return lines.join('');
+}
+/**
+ * The voice line: whether a session is live, and what it is.
+ * @param reply - the last status, if any.
+ * @param audio - what the microphone is doing.
+ * @returns one line of plain text.
+ */
+function summariseVoice(reply, audio) {
+    const microphone = audio.kind === 'failed' ? `microphone: failed — ${audio.reason}` : `microphone: ${audio.kind}`;
+    if (reply === null)
+        return `no answer yet · ${microphone}`;
+    const voice = reply.voice;
+    // `null` is "nobody answered the question", which is a composition without an agent row — deliberately
+    // not the same statement as a session that is merely closed.
+    if (voice === null || voice === undefined)
+        return `voice: no agent is mounted in this profile · ${microphone}`;
+    const where = voice.provider === undefined ? '' : ` · ${voice.provider}/${voice.model ?? '?'}`;
+    const which = voice.sessionId === undefined ? '' : ` · ${voice.sessionId}`;
+    return `voice: ${voice.open ? 'open' : 'closed'}${where}${which} · ${microphone}`;
 }
 /**
- * The client plugin. Publishes the client on a global and releases it with the plugin.
+ * The route line: what this socket is, and the last thing the journal recorded.
+ * @param reply - the last status.
+ * @returns one line of plain text.
+ */
+function summariseRoute(reply) {
+    const last = reply.journal?.last?.kind;
+    return [
+        reply.audio?.path ?? 'the audio route',
+        `${String(reply.audio?.clients ?? 0)} socket(s)`,
+        `journal ${String(reply.journal?.size ?? 0)}`,
+        ...last === undefined ? [] : [`last ${last}`],
+    ].join(' · ');
+}
+/**
+ * The buttons above the settings.
  *
- * There is no UI surface yet, so a global is how it is driven — a settings card is its own increment and a
- * bigger one than this. `inject` is empty for the same reason: nothing here needs another plugin.
+ * The microphone's own button is the on-switch this sprint exists to provide: what used to be a
+ * `globalThis` call in a devtools console is now the first control in the panel.
+ * @param audio - what the microphone is doing.
+ * @returns the markup.
+ */
+function buttons(audio) {
+    const live = audio.kind === 'live';
+    return [
+        `<button data-action="${live ? 'disconnect' : 'connect'}">${live ? 'Disconnect microphone' : 'Connect microphone'}</button>`,
+        '<button data-action="voice-start">Start voice</button>',
+        '<button data-action="voice-stop">Stop voice</button>',
+        '<button data-action="refresh">Refresh</button>',
+    ].join(' ');
+}
+/**
+ * One setting's row.
+ *
+ * Three classes, three treatments, and the gate's rule is the reason: a live field gets a control, a
+ * session-bound field says what it would take to change it, and a restart-bound field is not rendered.
+ * @param entry - the setting as `status` reported it.
+ * @param notes - what the last change to each setting produced.
+ * @returns the markup for one row.
+ */
+function settingRow(entry, notes) {
+    const key = escapeHtml(entry.key);
+    const label = `<span data-dsh-strip-label>${escapeHtml(entry.describe ?? entry.field)}</span>`;
+    const note = notes[entry.key] === undefined
+        ? ''
+        : `<em data-note="${key}">${escapeHtml(notes[entry.key])}</em>`;
+    if (entry.scope !== 'live') {
+        return `<li data-key="${key}" data-scope="session">${label}<b>${escapeHtml(show(entry.value))}</b>`
+            + `<em>fixed when the session opens — reconnect to apply</em>${note}</li>`;
+    }
+    // The channel has a verb for exactly one purpose — steering at a session — and this is the field it
+    // means. Everything else goes through `set <key>=<value>`.
+    const action = entry.field === 'sessionId' && entry.kind === 'string' ? 'steer' : 'set';
+    const control = entry.choices !== undefined && entry.choices.length > 0
+        ? `<select data-input="${key}">${choiceOptions(entry, entry.choices)}</select>`
+        : `<input data-input="${key}" value="${escapeHtml(show(entry.value))}">`;
+    const name = action === 'steer' ? 'Steer' : 'Set';
+    return `<li data-key="${key}" data-scope="live">${label}${control}`
+        + `<button data-action="${action}" data-key="${key}">${name}</button>${note}</li>`;
+}
+/**
+ * A picker's options, with the value in force always among them.
+ * @param entry - the setting, for its value.
+ * @param candidates - the values it declared. Passed in rather than read here: this is only ever called
+ *   for a setting that has a non-empty list, and a fallback for the case that cannot happen is a branch
+ *   the coverage gate rightly flags as dead.
+ * @returns the markup for each option.
+ */
+function choiceOptions(entry, candidates) {
+    const current = show(entry.value);
+    // A value that is not among the candidates is offered anyway. A select that silently showed the first
+    // candidate instead of the value actually in force would be lying about the state, which is the one
+    // thing a control plane must not do.
+    const all = candidates.includes(current) ? candidates : [current, ...candidates];
+    return all.map(choice => `<option value="${escapeHtml(choice)}"${choice === current ? ' selected' : ''}>${escapeHtml(choice)}</option>`).join('');
+}
+/**
+ * Mount the panel on its element.
+ *
+ * Reads `status` once, then renders — and renders again after every action, because a control that
+ * reported an outcome without showing the state it produced would leave the reader unsure which of the two
+ * they are looking at.
+ * @param deps - the element, the transport and the microphone's own controls.
+ * @returns the panel's handle.
+ */
+function mountStrip(deps) {
+    let reply = null;
+    const notes = {};
+    let notice = '';
+    const paint = () => {
+        deps.root.innerHTML = renderStrip({ reply, notes, notice, audio: deps.audio() });
+    };
+    const refresh = async () => {
+        try {
+            reply = await deps.request('status');
+        }
+        catch (error) {
+            // Nothing was sent, or nothing came back: the panel says which, rather than showing a stale state as
+            // if it were current.
+            notice = error instanceof Error ? error.message : String(error);
+        }
+        paint();
+    };
+    /**
+     * Send one frame and report what came back, then re-render.
+     * @param frame - the control frame.
+     * @param fieldKey - the setting the change was about, when it was about one.
+     * @param done - what to say when it worked.
+     */
+    const send = async (frame, fieldKey, done) => {
+        let line;
+        try {
+            const answer = await deps.request(frame);
+            // A refusal carries the reason written to be relayed verbatim, so it is relayed rather than
+            // translated — including for a field frozen by its class.
+            line = answer.ok ? done : `${answer.code ?? 'refused'}: ${answer.reason ?? 'no reason given'}`;
+        }
+        catch (error) {
+            line = error instanceof Error ? error.message : String(error);
+        }
+        if (fieldKey === undefined)
+            notice = line;
+        else
+            notes[fieldKey] = line;
+        await refresh();
+    };
+    const onClick = (event) => {
+        const action = event.target?.dataset?.action;
+        if (action === undefined)
+            return;
+        const key = event.target?.dataset?.key;
+        const value = key === undefined ? undefined : deps.root.querySelector(`[data-input="${key}"]`)?.value;
+        const act = async () => {
+            // Cleared per action: a notice from the last one is about the last one, and leaving it up would make
+            // a successful reconnect read as a failed one.
+            notice = '';
+            switch (action) {
+                case 'refresh':
+                    await refresh();
+                    return;
+                case 'disconnect':
+                    deps.disconnect();
+                    await refresh();
+                    return;
+                case 'connect': {
+                    const reached = await deps.connect();
+                    if (reached.kind === 'failed')
+                        notice = reached.reason;
+                    await refresh();
+                    return;
+                }
+                case 'voice-start':
+                    await send('start', undefined, 'voice started');
+                    return;
+                case 'voice-stop':
+                    await send('stop', undefined, 'voice stopped');
+                    return;
+                case 'steer':
+                    await send(`steer ${value ?? ''}`, key, 'steered');
+                    return;
+                case 'set': await send(`set ${key ?? ''}=${value ?? ''}`, key, 'applied');
+            }
+        };
+        void act();
+    };
+    deps.root.addEventListener('click', onClick);
+    return { refresh, state: () => ({ reply, notes, notice, audio: deps.audio() }) };
+}
+/**
+ * The client plugin. Publishes the client and the strip on a global, and releases them with the plugin.
+ *
+ * `inject` is empty on purpose: nothing here needs another plugin, and a client face that needs nothing
+ * cannot be broken by another plugin's absence.
+ *
+ * The global is **no longer the on-switch**. S2 story 3 put a panel in the app, and the panel's buttons
+ * are how anyone starts a microphone; the global is now the seam between the injected markup and this
+ * bundle, which is a different thing from a user interface that only exists in a devtools console.
  *
  * @param ctx - the client context, used only to own the lifetime.
  */
 function apply(ctx) {
     const client = createAudioClient(defaultDeps());
+    let mounted = false;
+    /**
+     * Render the panel into the element the injected markup provides.
+     *
+     * Called twice on purpose — once here, and once by the injected bootstrap script — because the two
+     * orders are both possible: this bundle is materialised by the module table, and the markup arrives with
+     * the body rows. Whichever runs second finds the panel already there and does nothing.
+     */
+    const mount = () => {
+        if (mounted)
+            return;
+        const root = stripRoot(globalThis);
+        if (root === null)
+            return;
+        mounted = true;
+        const strip = mountStrip({
+            root,
+            request: (frame) => client.request(frame),
+            connect: () => client.start(),
+            disconnect: () => { client.stop(); },
+            audio: () => client.state(),
+        });
+        void strip.refresh();
+    };
     globalThis[exports.GLOBAL_KEY] = {
         start: () => client.start(),
         stop: () => { client.stop(); },
         state: () => client.state(),
+        request: (frame) => client.request(frame),
+        mount,
     };
+    mount();
     // A held microphone and a live audio graph must not outlive the plugin that opened them.
     ctx.effect(() => () => { client.stop(); }, 'realtime-audio-client');
 }

package/lib/control.d.ts

@@ -0,0 +1,173 @@
+/**
+ * The control channel: verbs, sent as text frames on the socket that already carries audio.
+ *
+ * Until this module there was no way to drive the plugin without a console. The socket was duplex and
+ * carried PCM16 in both directions, and a text frame was explicitly *not* part of its contract; the
+ * client half published itself on a `globalThis` key and that global was the on-switch. Two restarts
+ * and a false lead went into changing which session the voice steered, because the config was read at
+ * boot and only at boot.
+ *
+ * So this is a deliberate widening of a documented contract, and it is written as a **channel** rather
+ * than as a second API: one text frame in, exactly one text frame out, on the socket the client already
+ * holds.
+ *
+ * Five properties are load-bearing.
+ *
+ * - **Every frame is answered.** A control frame the channel cannot parse is answered with the reason,
+ *   not dropped — the same rule `set` follows one layer down. A channel that reports nothing is
+ *   indistinguishable from one that never received the frame.
+ * - **The reply is JSON, and small.** It carries the values a status surface needs and no prose to
+ *   parse: `ok`, the verb as it was sent, and the fields for that verb.
+ * - **`steer` is a resolution, not a special case.** The verb addresses whichever plugin declares a live
+ *   `sessionId`; it refuses with a reason rather than guessing when none or several do.
+ * - **`set` goes through the settings surface and nowhere else**, so a change on this channel takes the
+ *   identical path — same parse, same refusal, same journal entry — as one from any other control plane.
+ * - **The verb vocabulary is closed.** A typo answers with the verbs that exist, because a silent
+ *   fall-through is how a user concludes the feature is missing.
+ *
+ * @module dsh-realtime-audio-ws/control
+ */
+import type { Journal, JournalEntry, RealtimeSettingInfo, RealtimeSettingRefusalCode, RealtimeSettings } from 'dsh-realtime';
+import type { RealtimeSessionRefusal, RealtimeSessionRequestOutcome, RealtimeVoiceStatus } from 'dsh-realtime-agent';
+/** The verbs this channel answers. Closed on purpose: see the module note. */
+export type ControlVerb = 'status' | 'start' | 'stop' | 'steer' | 'set';
+/**
+ * Why a control frame was refused.
+ *
+ * The three settings codes are carried through unchanged, because they are the seam's vocabulary and a
+ * client should branch on one set of codes rather than on a translation of them.
+ */
+export type ControlRefusalCode = 
+/** The first word is not a verb this channel has. */
+'UNKNOWN_VERB'
+/** The frame is malformed: a missing argument, an unexpected one, or a `set` with no `=`. */
+ | 'INVALID_CONTROL'
+/** `steer` found no plugin declaring a live `sessionId`. */
+ | 'NO_STEER_TARGET'
+/** `steer` found more than one, so the key to change is the caller's to name. */
+ | 'AMBIGUOUS_STEER_TARGET'
+/** The verb could not be carried out at all — nothing answered a query it needs, or it threw. */
+ | 'CONTROL_FAILED'
+/** No setting is registered under that key. */
+ | Extract<RealtimeSettingRefusalCode, 'UNKNOWN_SETTING'>
+/** The setting exists and its class cannot honour a change: it needs a reconnect, or a restart. */
+ | Extract<RealtimeSettingRefusalCode, 'FROZEN_SETTING'>
+/** The value did not parse, or the setting's own rules rejected it. */
+ | Extract<RealtimeSettingRefusalCode, 'INVALID_SETTING'>;
+/** One parsed control frame. */
+export type ControlCommand = {
+    readonly ok: true;
+    readonly verb: 'status' | 'start' | 'stop';
+} | {
+    readonly ok: true;
+    readonly verb: 'steer';
+    readonly sessionId: string;
+} | {
+    readonly ok: true;
+    readonly verb: 'set';
+    readonly key: string;
+    readonly value: string;
+} | {
+    readonly ok: false;
+    readonly verb: string;
+    readonly code: ControlRefusalCode;
+    readonly reason: string;
+};
+/** A refusal, as any verb can produce one. */
+export interface ControlRefusedReply {
+    readonly ok: false;
+    /** The verb as it was sent — including a word that is not a verb, so a client can pair the reply. */
+    readonly verb: string;
+    readonly code: ControlRefusalCode;
+    readonly reason: string;
+    /** The setting a `steer` or `set` addressed, when one was addressed. */
+    readonly key?: string;
+}
+/** `status`: what this route is carrying, what the voice is doing, and what a change can reach. */
+export interface ControlStatusReply {
+    readonly ok: true;
+    readonly verb: 'status';
+    /** This route's own facts. */
+    readonly audio: {
+        readonly path: string;
+        readonly clients: number;
+    };
+    /**
+     * The voice session's state, or `null` when **no plugin answered the query** — which is what a
+     * composition with no agent row looks like, and is deliberately not the same as a session that is
+     * merely closed (that answers `open: false`).
+     */
+    readonly voice: RealtimeVoiceStatus | null;
+    /** Every setting the running plugins declare, in registration order, with the values read now. */
+    readonly settings: readonly RealtimeSettingInfo[];
+    /** The journal's size and its last entry — enough to see that *something* just happened. */
+    readonly journal: {
+        readonly size: number;
+        readonly oldestSeq: number | undefined;
+        readonly last: JournalEntry | null;
+    };
+}
+/** `start` / `stop`: what the request produced, not merely that it was made. */
+export interface ControlSessionReply {
+    readonly ok: boolean;
+    readonly verb: 'start' | 'stop';
+    /** The state **after** the attempt. */
+    readonly voice: RealtimeVoiceStatus;
+    /** Present when the request did not achieve what it asked for. */
+    readonly refusal?: RealtimeSessionRefusal;
+}
+/** `set` / `steer`: the change that landed, and the value the setting now holds. */
+export interface ControlSettingReply {
+    readonly ok: true;
+    readonly verb: 'set' | 'steer';
+    readonly key: string;
+    /** What the setting is now — re-read from its owner, and `undefined` when the setting is write-only. */
+    readonly value: unknown;
+}
+/** What one control frame produced. */
+export type ControlReply = ControlRefusedReply | ControlStatusReply | ControlSessionReply | ControlSettingReply;
+/** What {@link createControlHandler} needs from the plugin that owns the route. */
+export interface ControlDeps {
+    /** The seam's settings surface: the only path a change takes. */
+    readonly settings: Pick<RealtimeSettings, 'list' | 'apply'>;
+    /** The seam's journal, for the size and the last entry a status reports. */
+    readonly journal: Pick<Journal, 'snapshot'>;
+    /** This route's own pathname, reported as-is. */
+    readonly path: string;
+    /** How many audio sockets this route is carrying right now. */
+    readonly clients: () => number;
+    /**
+     * The voice session's state.
+     *
+     * `undefined` means nothing answered; a rejection means something answered badly, and the two are kept
+     * apart — the first is a composition without the agent, the second is a finding.
+     */
+    readonly voice: () => Promise<RealtimeVoiceStatus | undefined>;
+    /** Run one of the two session requests the transport already makes. */
+    readonly request: (verb: 'start' | 'stop') => Promise<RealtimeSessionRequestOutcome | undefined>;
+}
+/**
+ * Read one text frame as a control command.
+ *
+ * A control frame is a **line**, so its line ending is stripped and nothing else is: `set x= 5` and
+ * `set x=5` are two different requests, and a channel that normalised one into the other would apply a
+ * change the caller did not ask for. For the same reason the verbs are matched exactly — an `INVALID_CONTROL`
+ * for `STATUS` is a better answer than a guess about intent, because it can be read and fixed.
+ *
+ * @param frame - the frame as it arrived, without its line ending.
+ * @returns the command, or a refusal naming the frame's fault.
+ */
+export declare function parseControlFrame(frame: string): ControlCommand;
+/**
+ * Build the channel's handler.
+ *
+ * The returned function is **total**: every frame it is given produces exactly one reply string, and it
+ * never rejects. That is a contract, not a hope — the caller writes the reply into a socket and has no
+ * one to catch a rejection, and a control frame that produces nothing at all is the silence this
+ * project keeps having to pay for.
+ *
+ * @param deps - the settings surface, the request edges, and this route's own facts.
+ * @returns a handler taking one frame and answering with the reply to send.
+ */
+export declare function createControlHandler(deps: ControlDeps): (frame: string) => Promise<string>;
+//# sourceMappingURL=control.d.ts.map

package/lib/control.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"control.d.ts","sourceRoot":"","sources":["../src/control.ts"],"names":[],"mappings":"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"}