feat(orchestrator): Gibberlink radio mode with ggwave and a fallback selector (018)
A new radio mode sends each spoken row as ggwave frames of at most 140 bytes: frame 1 carries the full session id, later frames its 8-character prefix, each with n/m. engines.sound_of() gives every speaker one of the four audible ggwave protocols that decode every frame length, plus its own stereo position, by a stable hash. The vendored ggwave 0.4.0 (MIT, LICENSE kept, sha256 pinned in test_hub_artifacts) runs only in the /gibberlink encoder page, sandboxed into an opaque origin with eval and WebAssembly but no connection; the hub page frames it (frame-src 'self') and review pages refuse framing (frame-ancestors 'none'). The radio gear gains a fallback selector (Gibberlink, Morse, Hiss) for rows that speech cannot play. Accepted MEDUSA false positives (security.py accept after kvb-think-criticize, 2026-11-17): engines.py FTSCAN-231 INF-SCAN-2638 INF-SCAN-2057 STG009 B603; handler.py FTSC-SCAN-089 B105 EXA002 EXA006; view.py WEB-FLASK-004 FINE-043 LO002. 🎯 Fix: 91 % 💥 Break: 4 % 💸 Tokens: – ⏱️ Velocity: – 🛡️ Security: 100 % 🏆 Score: 87 🚦 Gate: ✅ 90/5, tokens and velocity <= 100, security 100 % Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
af3555e88b
commit
621dc7536f
23 files changed
+1021
-34
No files matched your search
@@ -0,0 +1,15 @@
|
||||
<!doctype html>
|
||||
<html lang="en">
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<title>Gibberlink encoder</title>
|
||||
<script nonce="{{ nonce }}" src="/vendor/ggwave.js"></script>
|
||||
<script nonce="{{ nonce }}">
|
||||
{% include "gibberlink.js" %}
|
||||
{# ggwave fetches its embedded data: wasm first and decodes the bytes itself when that fails; rejecting at once keeps connect-src 'none' from logging a violation #}
|
||||
window.fetch = () => Promise.reject(new TypeError("the Gibberlink encoder has no network"));
|
||||
Gibberlink.serve(window, ggwave_factory({print: () => undefined, printErr: () => undefined}));
|
||||
</script>
|
||||
</head>
|
||||
<body></body>
|
||||
</html>
|
||||
@@ -0,0 +1,50 @@
|
||||
const Gibberlink = (() => {
|
||||
"use strict";
|
||||
const VOLUME = 50;
|
||||
const PREFIX = "GGWAVE_PROTOCOL_";
|
||||
|
||||
/**
|
||||
* @param {object} ggwave the loaded ggwave module.
|
||||
* @param {object} request protocol, a ggwave protocol name without its prefix, and frames, the frame texts.
|
||||
* @returns {object} rate and samples: the samples of each frame at ggwave's own output rate; the vendored build's frames at 44.1 kHz do not decode, so the page resamples instead.
|
||||
*/
|
||||
function encode(ggwave, request) {
|
||||
const {protocol, frames} = request;
|
||||
const key = `${PREFIX}${protocol}`;
|
||||
if (typeof protocol !== "string" || !Object.hasOwn(ggwave.ProtocolId, key) || !Array.isArray(frames) || !frames.every((frame) => typeof frame === "string")) {
|
||||
throw new Error("refused: the request needs a known protocol and text frames");
|
||||
}
|
||||
const parameters = ggwave.getDefaultParameters();
|
||||
const instance = ggwave.init(parameters);
|
||||
try {
|
||||
return {rate: parameters.sampleRateOut, samples: frames.map((frame) => {
|
||||
const wave = ggwave.encode(instance, frame, ggwave.ProtocolId[key], VOLUME);
|
||||
return new Float32Array(wave.buffer.slice(wave.byteOffset, wave.byteOffset + wave.length));
|
||||
})};
|
||||
} finally {
|
||||
ggwave.free(instance);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {Window} scope the encoder frame's window; it answers only its parent.
|
||||
* @param {Promise<object>} ready the ggwave module once loaded.
|
||||
*/
|
||||
function serve(scope, ready) {
|
||||
scope.addEventListener("message", (event) => {
|
||||
if (event.source !== scope.parent || !event.data || typeof event.data.id !== "number") {
|
||||
return;
|
||||
}
|
||||
const {id} = event.data;
|
||||
ready.then((ggwave) => encode(ggwave, event.data)).then(
|
||||
({rate, samples}) => scope.parent.postMessage({id, rate, samples}, "*", samples.map((part) => part.buffer)),
|
||||
(error) => scope.parent.postMessage({id, error: String((error && error.message) || error)}, "*"),
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
return {VOLUME, encode, serve};
|
||||
})();
|
||||
if (typeof module === "object" && module.exports) {
|
||||
module.exports = Gibberlink;
|
||||
}
|
||||
@@ -631,6 +631,8 @@ pre.notes { margin: 0; padding: 8px 10px; background: var(--sunken); border-radi
|
||||
|
||||
{% include "page-morse.js" %}
|
||||
|
||||
{% include "page-gibberlink.js" %}
|
||||
|
||||
{% include "page-mic.js" %}
|
||||
|
||||
{% include "page-bubbles.js" %}
|
||||
|
||||
@@ -0,0 +1,87 @@
|
||||
const GIBBER = {gap: 0.3, timeout: 15000, route: "/gibberlink"};
|
||||
const gibber = {frame: null, ready: null, pending: new Map(), next: 0};
|
||||
|
||||
function gibberFrame() {
|
||||
if (!gibber.frame) {
|
||||
const frame = h("iframe", {class: "gibberlink-encoder", src: GIBBER.route, sandbox: "allow-scripts", title: "Gibberlink encoder", "aria-hidden": "true", tabindex: "-1", hidden: true});
|
||||
gibber.ready = new Promise((resolve) => frame.addEventListener("load", resolve, {once: true}));
|
||||
window.addEventListener("message", gibberAnswer);
|
||||
document.body.append(frame);
|
||||
gibber.frame = frame;
|
||||
}
|
||||
return gibber;
|
||||
}
|
||||
|
||||
function gibberAnswer(event) {
|
||||
const waiting = gibber.frame && event.source === gibber.frame.contentWindow && event.data ? gibber.pending.get(event.data.id) : null;
|
||||
if (!waiting) {
|
||||
return;
|
||||
}
|
||||
gibber.pending.delete(event.data.id);
|
||||
window.clearTimeout(waiting.timer);
|
||||
const {rate, samples, error} = event.data;
|
||||
if (error) {
|
||||
waiting.reject(new Error(String(error)));
|
||||
} else if (Number.isFinite(rate) && rate > 0 && Array.isArray(samples) && samples.every((part) => part instanceof Float32Array)) {
|
||||
waiting.resolve({rate, samples});
|
||||
} else {
|
||||
waiting.reject(new Error("the Gibberlink encoder answered no samples"));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {object} step a Gibberlink step with frames and protocol.
|
||||
* @returns {Promise<object>} rate and samples: the samples of each frame from the sandboxed encoder frame, at its rate.
|
||||
*/
|
||||
function gibberEncode(step) {
|
||||
const {frame, ready, pending} = gibberFrame();
|
||||
gibber.next += 1;
|
||||
const id = gibber.next;
|
||||
return new Promise((resolve, reject) => {
|
||||
const timer = window.setTimeout(() => {
|
||||
pending.delete(id);
|
||||
reject(new Error("the Gibberlink encoder did not answer"));
|
||||
}, GIBBER.timeout);
|
||||
pending.set(id, {resolve, reject, timer});
|
||||
ready.then(() => frame.contentWindow.postMessage({id, protocol: step.protocol, frames: step.frames}, "*"));
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {AudioContext} sound the page's audio context.
|
||||
* @param {object} item the row that sounds.
|
||||
* @param {object} step its Gibberlink step: frames, protocol and pan.
|
||||
* @returns {Promise<boolean>} whether the whole row sounded uncut: the frames one after another with a short gap, at the row's tone volume times the squelch, in the sender's stereo position.
|
||||
*/
|
||||
async function keyGibberlink(sound, item, step) {
|
||||
const level = loudness(item.tone);
|
||||
if (level <= 0 || !step.frames.length) {
|
||||
return false;
|
||||
}
|
||||
const {rate, samples: parts} = await gibberEncode(step);
|
||||
if (speech.item !== item) {
|
||||
return false;
|
||||
}
|
||||
if (!allows(rendered(item, item.at), "gibberlink")) {
|
||||
item.cut = true;
|
||||
return false;
|
||||
}
|
||||
const gap = Math.round(rate * GIBBER.gap);
|
||||
const buffer = sound.createBuffer(1, parts.reduce((sum, part) => sum + part.length + gap, 0), rate);
|
||||
const data = buffer.getChannelData(0);
|
||||
parts.reduce((at, part) => {
|
||||
data.set(part, at);
|
||||
return at + part.length + gap;
|
||||
}, 0);
|
||||
const source = sound.createBufferSource();
|
||||
const gain = sound.createGain();
|
||||
const pan = sound.createStereoPanner();
|
||||
gain.gain.value = level;
|
||||
pan.pan.value = step.pan;
|
||||
source.buffer = buffer;
|
||||
source.connect(gain).connect(pan).connect(sound.destination);
|
||||
voicePace(item, Infinity, buffer.duration);
|
||||
const ended = sounded(item, source, buffer.duration);
|
||||
source.start();
|
||||
return ended.then(() => speech.item === item && !item.cut);
|
||||
}
|
||||
@@ -1,10 +1,16 @@
|
||||
const STATION_TONES = {playing: "ok", loading: "info", reload: "info", blocked: "warn", error: "bad", due: "teal", stopped: "neutral", idle: "neutral", off: "neutral"};
|
||||
const NOTE_ID = /^[0-9a-f]{16}$/;
|
||||
const MODE_LABELS = {
|
||||
auto: ["bi-volume-up", "Auto", "Auto: speech while the host CPU lies below the threshold, otherwise the noise burst"],
|
||||
quiet: ["bi-soundwave", "Quiet", "Quiet: the noise burst only, never speech; MAYDAY, PAN-PAN and Sécurité still sound their procedure word"],
|
||||
auto: ["bi-volume-up", "Auto", "Auto: speech while the host CPU lies below the threshold, otherwise the fallback picked under Read aloud"],
|
||||
quiet: ["bi-soundwave", "Quiet", "Quiet: the fallback picked under Read aloud, never speech; MAYDAY, PAN-PAN and Sécurité still sound their procedure word"],
|
||||
silence: ["bi-volume-mute", "Silence", "Silence: no sound, bubbles and log only; MAYDAY, PAN-PAN and Sécurité still sound their procedure word"],
|
||||
morse: ["bi-three-dots", "Morse", "Morse: every message keyed whole in Morse, in its sender's own pitch, at the hub's Morse speed; MAYDAY keys SOS"],
|
||||
gibberlink: ["bi-robot", "Gibberlink", "Gibberlink: every message sent whole as ggwave data sound a machine can decode, in its sender's own protocol and stereo position; MAYDAY, PAN-PAN and Sécurité still sound their procedure word"],
|
||||
};
|
||||
const FALLBACK_LABELS = {
|
||||
gibberlink: ["Gibberlink", "Where speech cannot play, send the rest as ggwave data sound"],
|
||||
morse: ["Morse", "Where speech cannot play, key the whole message in Morse"],
|
||||
burst: ["Hiss", "Where speech cannot play, play the short noise burst"],
|
||||
};
|
||||
const radioParts = {bars: [], devices: [], logs: [], speaks: []};
|
||||
const liveParts = (kind) => radioParts[kind].filter((part) => part.root.isConnected);
|
||||
@@ -89,7 +95,7 @@
|
||||
mode.textContent = MODE_LABELS[radioSet.mode][1];
|
||||
cpu.textContent = gate.cpu === null ? "CPU ?" : `CPU ${Math.round(gate.cpu)} %`;
|
||||
cpu.dataset.open = String(gate.open);
|
||||
cpu.title = `${gate.cpu === null ? "No host CPU sample of the last two minutes" : `Host CPU ${fixed(gate.cpu)} %`}, threshold: ${RadioSet.gateLabel(gate.threshold)}${gate.open ? "" : ", so the hub renders no new speech line and the radio plays the burst"}`;
|
||||
cpu.title = `${gate.cpu === null ? "No host CPU sample of the last two minutes" : `Host CPU ${fixed(gate.cpu)} %`}, threshold: ${RadioSet.gateLabel(gate.threshold)}${gate.open ? "" : ", so the hub renders no new speech line and the radio plays the fallback"}`;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -293,10 +299,15 @@
|
||||
keepRadio({muted: radioSet.muted.includes(key) ? radioSet.muted.filter((name) => name !== key) : [...radioSet.muted, key]});
|
||||
redrawFilters();
|
||||
}, false));
|
||||
const fallbacks = RadioSet.FALLBACKS.map((id) => chip(FALLBACK_LABELS[id][0], radioSet.fallback === id, FALLBACK_LABELS[id][1], () => {
|
||||
keepRadio({fallback: id});
|
||||
redrawFilters();
|
||||
}, false));
|
||||
return h("div", {class: "radio-read", "aria-label": "Read aloud"},
|
||||
h("p", {class: "muted"}, state.speech.tts ? "The radio sounds for these classes and agents, each speaker with its own voice; MAYDAY always sounds." : `The hub speaks no line: ${state.speech.tts_off}. The burst and the procedure words stand in.`),
|
||||
h("p", {class: "muted"}, state.speech.tts ? "The radio sounds for these classes and agents, each speaker with its own voice; MAYDAY always sounds." : `The hub speaks no line: ${state.speech.tts_off}. The fallback and the procedure words stand in.`),
|
||||
h("div", {class: "chips", role: "group", "aria-label": "Classes"}, classes),
|
||||
agents.length ? h("div", {class: "chips", role: "group", "aria-label": "Agents"}, agents) : null,
|
||||
h("div", {class: "chips radio-fallback", role: "group", "aria-label": "Fallback", title: "Fallback: what plays in Auto above the threshold and in Quiet, kept in this browser"}, h("span", {class: "chips-label"}, "Fallback"), fallbacks),
|
||||
morseSpeed());
|
||||
}
|
||||
|
||||
|
||||
@@ -27,11 +27,11 @@
|
||||
|
||||
/**
|
||||
* @param {object|undefined} step the step the radio set plans now at the index that plays.
|
||||
* @param {string} kind word, speech or burst: what plays or is about to play there.
|
||||
* @returns {boolean} whether that sound may play: the planned kind, or the burst standing in for a planned speech line.
|
||||
* @param {string} kind word, speech, or a fallback kind (gibberlink, morse, burst): what plays or is about to play there.
|
||||
* @returns {boolean} whether that sound may play: the planned kind, or a fallback standing in for a planned speech line.
|
||||
*/
|
||||
function allows(step, kind) {
|
||||
return Boolean(step) && (step.kind === kind || (kind === "burst" && step.kind === "speech"));
|
||||
return Boolean(step) && (step.kind === kind || (RadioSet.FALLBACKS.includes(kind) && step.kind === "speech"));
|
||||
}
|
||||
|
||||
function speechFailed(lines) {
|
||||
@@ -54,7 +54,7 @@
|
||||
function preempt() {
|
||||
const {item, source} = speech;
|
||||
const [first] = speech.pending;
|
||||
if (item && source && item.playing === "morse" && first && Voice.rank(first) < Voice.rank(item)) {
|
||||
if (item && source && RadioSet.KEYED.includes(item.playing) && first && Voice.rank(first) < Voice.rank(item)) {
|
||||
speech.item = null;
|
||||
speech.pending = Voice.enqueue(speech.pending, item, SPEECH_QUEUE);
|
||||
source.stop();
|
||||
@@ -224,8 +224,8 @@
|
||||
await burst(audio, item);
|
||||
continue;
|
||||
}
|
||||
if (step.kind === "morse") {
|
||||
voiced = (await keyMorse(audio, item, step)) || voiced;
|
||||
if (RadioSet.KEYED.includes(step.kind)) {
|
||||
voiced = (await keyed(audio, item, step)) || voiced;
|
||||
done -= Number(item.cut);
|
||||
continue;
|
||||
}
|
||||
@@ -244,11 +244,16 @@
|
||||
speechFailed([failed]);
|
||||
}
|
||||
if (failed && step.kind === "speech" && speech.item === item && allows(stepOf(item, done), "burst")) {
|
||||
item.playing = "burst";
|
||||
await burst(audio, item);
|
||||
const stand = item.row ? RadioSet.standIn(item.row, radioSet) : {kind: "burst"};
|
||||
item.playing = stand.kind;
|
||||
await (stand.kind === "burst" ? burst(audio, item) : keyed(audio, item, stand));
|
||||
}
|
||||
}
|
||||
|
||||
function keyed(audio, item, step) {
|
||||
return step.kind === "morse" ? keyMorse(audio, item, step) : keyGibberlink(audio, item, step);
|
||||
}
|
||||
|
||||
async function pump() {
|
||||
if (speech.busy || !speech.pending.length) {
|
||||
return;
|
||||
|
||||
@@ -1,7 +1,10 @@
|
||||
const RadioSet = (() => {
|
||||
"use strict";
|
||||
const KEY = "kvb-orchestrator.radio";
|
||||
const MODES = ["auto", "quiet", "silence", "morse"];
|
||||
const MODES = ["auto", "quiet", "silence", "morse", "gibberlink"];
|
||||
const FALLBACKS = ["gibberlink", "morse", "burst"];
|
||||
const KEYED = ["morse", "gibberlink"];
|
||||
const FRAME = {bytes: 140, prefix: 8, key: 64};
|
||||
const TONES = ["mayday", "review", "direct", "radio"];
|
||||
const CLASSES = ["post", "call", "newsletter", "broadcast", "mayday", "pan-pan", "security"];
|
||||
const TO_ALL = new Set(["newsletter", "broadcast", "mayday", "pan-pan", "security"]);
|
||||
@@ -24,6 +27,7 @@ const RadioSet = (() => {
|
||||
};
|
||||
const DEFAULTS = {
|
||||
mode: "auto",
|
||||
fallback: "gibberlink",
|
||||
sounds: {mayday: {on: true, volume: 0.9}, review: {on: true, volume: 0.6}, direct: {on: true, volume: 0.5}, radio: {on: false, volume: 0.25}},
|
||||
squelch: 1,
|
||||
classes: ["mayday", "pan-pan", "security"],
|
||||
@@ -61,6 +65,7 @@ const RadioSet = (() => {
|
||||
const muted = Array.isArray(raw.muted) ? raw.muted.filter((key) => typeof key === "string" && key && key.length <= TEXT_LIMIT) : [];
|
||||
return {
|
||||
mode: MODES.includes(raw.mode) ? raw.mode : DEFAULTS.mode,
|
||||
fallback: FALLBACKS.includes(raw.fallback) ? raw.fallback : DEFAULTS.fallback,
|
||||
sounds: Object.fromEntries(TONES.map((name) => [name, tone(sounds[name], DEFAULTS.sounds[name])])),
|
||||
squelch: level(raw.squelch, DEFAULTS.squelch),
|
||||
classes: CLASSES.filter((name) => name === "mayday" || classes.includes(name)),
|
||||
@@ -82,11 +87,74 @@ const RadioSet = (() => {
|
||||
return {kind: "morse", sign: called ? row.called.join(" ") : sign, joined, text: `DE ${row.speaker} ${row.text.replace(MARKS, " ")}`, pitch: row.pitch};
|
||||
}
|
||||
|
||||
const utf8 = (char) => {
|
||||
const point = char.codePointAt(0);
|
||||
return point < 0x80 ? 1 : point < 0x800 ? 2 : point < 0x10000 ? 3 : 4;
|
||||
};
|
||||
|
||||
function fitting(chars, at, room) {
|
||||
let end = at;
|
||||
for (let left = room; end < chars.length && utf8(chars[end]) <= left; end += 1) {
|
||||
left -= utf8(chars[end]);
|
||||
}
|
||||
return end;
|
||||
}
|
||||
|
||||
function split(key, chars, count) {
|
||||
const own = Array.from(key);
|
||||
const full = own.slice(0, fitting(own, 0, FRAME.key)).join("");
|
||||
const prefix = own.slice(0, FRAME.prefix).join("");
|
||||
const out = [];
|
||||
let at = 0;
|
||||
do {
|
||||
const head = `${out.length ? prefix : full} ${out.length + 1}/${count} `;
|
||||
const end = fitting(chars, at, FRAME.bytes - Array.from(head).reduce((sum, char) => sum + utf8(char), 0));
|
||||
out.push(head + chars.slice(at, end).join(""));
|
||||
at = end;
|
||||
} while (at < chars.length);
|
||||
return out;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {object} row a radio row of the state with word, rest, voice and the Morse fields.
|
||||
* @param {string} key the sender's session key, the row's source; its first 64 bytes head frame 1.
|
||||
* @param {string} text the message without the hub's mark.
|
||||
* @returns {Array<string>} the frames of at most 140 UTF-8 bytes, each split between characters: frame 1 the key, `1/m` and text, every later frame the key's first 8 characters, `n/m` and text.
|
||||
*/
|
||||
function frames(key, text) {
|
||||
const chars = Array.from(text);
|
||||
for (let count = 1; ;) {
|
||||
const out = split(key, chars, count);
|
||||
if (out.length === count) {
|
||||
return out;
|
||||
}
|
||||
count = out.length;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {object} row a radio row with source, text, protocol and pan.
|
||||
* @returns {object} the whole row as kind "gibberlink": its frames, the sender's ggwave protocol and its stereo position.
|
||||
*/
|
||||
function gibberlink(row) {
|
||||
return {kind: "gibberlink", frames: frames(row.source, row.text.replace(MARKS, "").trim()), protocol: row.protocol, pan: row.pan};
|
||||
}
|
||||
|
||||
const STAND_INS = {gibberlink, morse, burst: () => ({kind: "burst"})};
|
||||
|
||||
/**
|
||||
* @param {object} row a radio row of the state.
|
||||
* @param {object} set the radio set.
|
||||
* @returns {object} the step its fallback pick plays where speech cannot: Gibberlink frames, Morse keying or the burst.
|
||||
*/
|
||||
function standIn(row, set) {
|
||||
return STAND_INS[set.fallback](row);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {object} row a radio row of the state with word, rest, voice, the Morse and the Gibberlink fields.
|
||||
* @param {object} set the radio set.
|
||||
* @param {Object<string, boolean>} live tts and open: whether the hub speaks at all and whether its CPU gate is open.
|
||||
* @returns {Array<{kind: string, text: (string|undefined)}>} what plays, in order: in Morse the whole row keyed once; else the procedure word line in every mode, then the spoken rest in Auto below the threshold, else the noise burst, nothing more in Silence.
|
||||
* @returns {Array<{kind: string, text: (string|undefined)}>} what plays, in order: in Morse the whole row keyed once; else the procedure word line in every mode, then in Gibberlink the frames of the whole row, in Auto below the threshold the spoken rest, else the fallback pick, nothing more in Silence.
|
||||
*/
|
||||
function plan(row, set, live) {
|
||||
if (!picked(row, set)) {
|
||||
@@ -99,8 +167,11 @@ const RadioSet = (() => {
|
||||
if (set.mode === "silence") {
|
||||
return word;
|
||||
}
|
||||
if (set.mode === "gibberlink") {
|
||||
return [...word, gibberlink(row)];
|
||||
}
|
||||
const spoken = set.mode === "auto" && live.tts && live.open && row.voice && row.rest;
|
||||
return [...word, spoken ? {kind: "speech", text: row.rest} : {kind: "burst"}];
|
||||
return [...word, spoken ? {kind: "speech", text: row.rest} : standIn(row, set)];
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -201,7 +272,7 @@ const RadioSet = (() => {
|
||||
return {...entry, chips: Object.fromEntries(CHIPS.map((name) => [name, ""])), q: ""};
|
||||
}
|
||||
|
||||
return {KEY, MODES, TONES, CLASSES, TABS, CHIPS, DEFAULTS, GATE, PROSIGNS, valid, picked, plan, burst, gateLabel, toAll, ledgerOf, logRows, counts, choices, cleared};
|
||||
return {KEY, MODES, FALLBACKS, KEYED, FRAME, TONES, CLASSES, TABS, CHIPS, DEFAULTS, GATE, PROSIGNS, valid, picked, frames, standIn, plan, burst, gateLabel, toAll, ledgerOf, logRows, counts, choices, cleared};
|
||||
})();
|
||||
if (typeof module === "object" && module.exports) {
|
||||
module.exports = RadioSet;
|
||||
|
||||
@@ -112,6 +112,7 @@ body.fit .spot-host { flex: none; }
|
||||
.knob-test { grid-column: 5; }
|
||||
.radio-read { display: grid; gap: var(--sp-2); }
|
||||
.radio-read .chips { margin-bottom: 0; }
|
||||
.radio-fallback .chips-label { color: var(--muted); font-size: var(--fs-sm); }
|
||||
.morse-speed { display: flex; flex-wrap: wrap; align-items: center; gap: var(--sp-1) var(--sp-2); min-width: 0; color: var(--muted); font-size: var(--fs-sm); }
|
||||
.morse-speed .knob { flex: 1 1 8rem; width: auto; }
|
||||
.morse-rate { font-family: var(--mono); font-variant-numeric: tabular-nums; white-space: nowrap; }
|
||||
|
||||
Reference in new issue
Block a user