@hraness/dawg 0.6.1 → 0.7.0

package/src/tui/vocoder-menu.ts

@@ -0,0 +1,244 @@
+/**
+ * Ctrl-k rows for the vocoder (0.7, vocoder.md §8): Effects › Voice ›
+ * Vocoder (Source picker, Preset, one row per VOCODER_PARAMS key in table
+ * order) and Voice › voice presets › Vocoder. Every row runs a
+ * `vocoder …` command, so it stages for the audition loop like any other.
+ */
+import type { NumberParam } from "../../core/params.ts";
+import type { Track } from "../../core/score.ts";
+import {
+  DEFAULT_VOCODER_PRESET,
+  VOCODER_INSTRUMENT,
+  VOCODER_PARAMS,
+  VOCODER_PRESETS,
+  VOCODER_PRESET_NAMES,
+  resolveVocoder,
+  vocoderPresetOf,
+  type TrackVocoder,
+} from "../../core/vocoder.ts";
+import {
+  vocoderEntryLines,
+  trackHasAudio,
+  vocoderCandidates,
+} from "../commands/vocoder.ts";
+import { num, specStep, type MenuContext, type MenuNode } from "./menu.ts";
+
+const NONE = "none";
+
+function trackOf(context: MenuContext): Track | undefined {
+  return context.score.tracks.find((track) => track.id === context.trackId);
+}
+
+/** One row per VOCODER_PARAMS key; x and `preset` return it to the preset. */
+function paramRow(vocoder: TrackVocoder, name: string): MenuNode {
+  const spec = VOCODER_PARAMS[name]!;
+  const own = (vocoder as Record<string, unknown>)[name];
+  const preset = vocoderPresetOf(vocoder);
+  const fallback = (VOCODER_PRESETS[preset].values as Record<string, unknown>)[
+    name
+  ];
+  const resolved = (resolveVocoder(vocoder) as Record<string, unknown>)[name];
+  if (spec.kind === "enum")
+    return {
+      kind: "choice",
+      label: name,
+      value: own === undefined ? "preset" : String(own),
+      options: ["preset", ...spec.values],
+      command: (option) =>
+        option === "preset"
+          ? `vocoder ${name} reset`
+          : `vocoder ${name} ${option}`,
+      help: `${spec.doc} · preset ${String(resolved)}`,
+    };
+  if (spec.kind === "boolean")
+    return {
+      kind: "choice",
+      label: name,
+      value: own === undefined ? "preset" : own ? "on" : "off",
+      options: ["preset", "on", "off"],
+      command: (option) =>
+        option === "preset"
+          ? `vocoder ${name} reset`
+          : `vocoder ${name} ${option}`,
+      help: `${spec.doc} · preset ${fallback ? "on" : "off"}`,
+    };
+  const number = spec as NumberParam;
+  // gate's preset value is "auto" (from the source's assets): show it as off.
+  const value = typeof resolved === "number" ? resolved : undefined;
+  return {
+    kind: "number",
+    label: name,
+    value,
+    min: number.min,
+    max: number.max,
+    step: specStep(number),
+    format: (v) => (number.unit ? `${num(v)} ${number.unit}` : num(v)),
+    command: (v) => `vocoder ${name} ${num(v)}`,
+    reset: `vocoder ${name} reset`,
+    ...(value === undefined ? { off: "auto", start: number.min } : {}),
+    help: `${number.doc} · preset ${typeof fallback === "number" ? num(fallback) : String(resolved ?? "auto")} · x resets`,
+  };
+}
+
+/** A source as the picker shows it: its name, or its id when names clash. */
+function sourceLabel(track: Track, all: readonly Track[]): string {
+  const clash = all.some((t) => t.id !== track.id && t.name === track.name);
+  return clash || !track.name.trim() ? track.id : track.name;
+}
+
+/** `vocoder src <name>`, quoted when the name has spaces. */
+function srcCommand(label: string): string {
+  return /\s/.test(label) ? `vocoder src "${label}"` : `vocoder src ${label}`;
+}
+
+function entryRows(): MenuNode[] {
+  return vocoderEntryLines().map((line, index) => ({
+    kind: "info",
+    label: index === 0 ? "no voice yet" : "",
+    value: line.trim(),
+  }));
+}
+
+/** The rows inside Effects › Voice › Vocoder for the focused track. */
+export function vocoderRows(context: MenuContext): MenuNode[] {
+  const track = trackOf(context);
+  if (!track || track.instrument === "kit") return [];
+  const vocoder = track.vocoder;
+  const candidates = vocoderCandidates(context.score, track.id);
+  const all = context.score.tracks;
+  if (!vocoder) {
+    if (trackHasAudio(track))
+      return [
+        {
+          kind: "action",
+          label: "vocode",
+          command: "vocoder",
+          help: "adds a vocoder track driven by this voice (follows the song's chords, or drones on the key's root); mutes it",
+        },
+      ];
+    if (candidates.length === 0) return entryRows();
+    return [
+      {
+        kind: "choice",
+        label: "source",
+        value: NONE,
+        options: [NONE, ...candidates.map((t) => sourceLabel(t, all))],
+        command: (option) =>
+          option === NONE ? "vocoder off" : srcCommand(option),
+        help: "the voice that shapes this track's sound",
+      },
+    ];
+  }
+  const others = context.score.tracks.filter(
+    (t) => t.id !== track.id && t.instrument !== "kit",
+  );
+  const options = [
+    ...candidates.map((t) => sourceLabel(t, all)),
+    ...others
+      .filter((t) => !candidates.some((c) => c.id === t.id))
+      .map((t) => sourceLabel(t, all)),
+  ];
+  const current = all.find((t) => t.id === vocoder.src);
+  const nodes: MenuNode[] = [
+    {
+      kind: "choice",
+      label: "source",
+      value: current ? sourceLabel(current, all) : (vocoder.src ?? NONE),
+      options: vocoder.src === undefined ? [NONE, ...options] : options,
+      command: (option) => (option === NONE ? "vocoder" : srcCommand(option)),
+      help: "the modulator; it is heard through the vocoder even when muted",
+    },
+    {
+      kind: "choice",
+      label: "preset",
+      value: vocoder.preset ?? DEFAULT_VOCODER_PRESET,
+      options: VOCODER_PRESET_NAMES,
+      command: (option) => `vocoder preset ${option}`,
+      help: "classic robot talkbox choir glass whisper smear lofi · keeps your overrides",
+    },
+    ...Object.keys(VOCODER_PARAMS).map((name) => paramRow(vocoder, name)),
+  ];
+  if (Object.keys(vocoder).some((key) => key !== "preset" && key !== "src"))
+    nodes.push({
+      kind: "action",
+      label: "reset to preset",
+      command: "vocoder reset",
+      help: "clear overrides, keep the source and preset",
+    });
+  nodes.push({
+    kind: "action",
+    label: "remove the vocoder",
+    command: "vocoder off",
+    help: "the track plays its own sound again",
+  });
+  return nodes;
+}
+
+/** Effects › Voice › Vocoder. */
+export function vocoderEffectNode(context: MenuContext): MenuNode[] {
+  const track = trackOf(context);
+  if (!track || track.instrument === "kit") return [];
+  const vocoder = track.vocoder;
+  return [
+    {
+      kind: "menu",
+      id: "voice:vocoder",
+      label: "vocoder",
+      detail: vocoder
+        ? `${vocoder.preset ?? DEFAULT_VOCODER_PRESET}${vocoder.src ? ` · from ${vocoder.src}` : " · no source"}`
+        : trackHasAudio(track)
+          ? "vocode"
+          : "off",
+      help: "a voice shapes this track's sound: robot, talkbox, choir",
+      build: vocoderRows,
+    },
+  ];
+}
+
+/** Voice › voice presets › Vocoder: the built-in carrier. */
+export function vocoderBrowseNode(context: MenuContext): MenuNode[] {
+  const track = trackOf(context);
+  return [
+    {
+      kind: "menu",
+      id: "voices:vocoder",
+      label: "vocoder",
+      detail: `${VOCODER_PRESET_NAMES.length} presets · robot, talkbox, choir …`,
+      help: "a built-in synth carrier spoken through a voice track",
+      build: (inner) => {
+        const here = trackOf(inner) ?? track;
+        if (here && trackHasAudio(here))
+          return [
+            {
+              kind: "action",
+              label: "vocode",
+              command: "vocoder",
+              help: "adds a vocoder track driven by this voice",
+            },
+          ];
+        if (here?.instrument !== VOCODER_INSTRUMENT)
+          return [
+            {
+              kind: "action",
+              label: "make a vocoder",
+              command: `instrument ${VOCODER_INSTRUMENT}`,
+              help: "a supersaw carrier; then pick its presets and source here",
+            },
+            ...(vocoderCandidates(inner.score, inner.trackId).length === 0
+              ? entryRows()
+              : []),
+          ];
+        return VOCODER_PRESET_NAMES.map((name): MenuNode => ({
+          kind: "action",
+          label: `${name.padEnd(8)} ${VOCODER_PRESETS[name].doc}`,
+          command: `vocoder ${name}`,
+          help: VOCODER_PRESETS[name].doc,
+        })).concat(
+          vocoderCandidates(inner.score, inner.trackId).length === 0
+            ? entryRows()
+            : vocoderRows(inner).filter((row) => row.label === "source"),
+        );
+      },
+    },
+  ];
+}

package/src/tui/wind-menu.ts

@@ -1,6 +1,6 @@
 /**
  * Ctrl-k menu rows for the wind engine (0.6.1): the "Winds and brass" group
- * under Sound › browse sounds, and the WIND_PARAMS rows under Sound ›
+ * under Sound › instruments, and the WIND_PARAMS rows under Sound ›
  * Parameters on a wind-engine track. Every row runs a `wind …` command.
  */
 import type { EnumParam, NumberParam } from "../../core/params.ts";
@@ -27,12 +27,12 @@ function presetRow(name: WindPresetName): MenuNode {
   };
 }
 
-/** Sound › browse sounds › Winds and brass: flutes, reeds, brass. */
+/** Sound › instruments › winds and brass: flutes, reeds, brass. */
 export function windsMenu(): MenuNode {
   return {
     kind: "menu",
     id: "winds",
-    label: "Winds and brass",
+    label: "winds and brass",
     detail: `${WIND_PRESET_NAMES.length} blown · flute, sax, trumpet …`,
     help: "breath-driven waveguides: flutes, reeds and brass; wind players 4 for a section",
     build: () =>

package/src/version.ts

@@ -0,0 +1,8 @@
+/**
+ * The package version, read from package.json by a static JSON import so
+ * `bun build --compile` embeds it: a runtime read relative to
+ * import.meta.url finds nothing inside a compiled binary.
+ */
+import pkg from "../package.json" with { type: "json" };
+
+export const VERSION: string = pkg.version;

package/src/web/fetch.ts

@@ -7,6 +7,7 @@
  */
 import { lookup as dnsLookup } from "node:dns/promises";
 import { isIP } from "node:net";
+import { checkServerIdentity, type PeerCertificate } from "node:tls";
 import {
   decodeEntities,
   describeFetchError,
@@ -81,26 +82,64 @@ function isPrivateV4(address: string): boolean {
   );
 }
 
-function isPrivateV6(address: string): boolean {
-  const lower = address.toLowerCase().split("%")[0]!;
-  if (lower === "::" || lower === "::1") return true;
-  const mapped = /^(?:0*:)*:?ffff:(\d+\.\d+\.\d+\.\d+)$/.exec(lower);
-  if (mapped) return isPrivateV4(mapped[1]!);
-  const hexMapped = /^(?:0*:)*:?ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/.exec(
-    lower,
-  );
-  if (hexMapped) {
-    const high = Number.parseInt(hexMapped[1]!, 16);
-    const low = Number.parseInt(hexMapped[2]!, 16);
-    return isPrivateV4(`${high >> 8}.${high & 0xff}.${low >> 8}.${low & 0xff}`);
+/** Expand an IPv6 address (zone stripped, embedded dotted IPv4 allowed) to 8 groups. */
+function expandV6(address: string): number[] | undefined {
+  let text = address.toLowerCase().split("%")[0]!;
+  const dotted = /(\d+)\.(\d+)\.(\d+)\.(\d+)$/.exec(text);
+  if (dotted) {
+    const [a, b, c, d] = dotted.slice(1).map(Number) as [
+      number,
+      number,
+      number,
+      number,
+    ];
+    text = `${text.slice(0, dotted.index)}${((a << 8) | b).toString(16)}:${((c << 8) | d).toString(16)}`;
   }
-  const first = Number.parseInt(lower.split(":")[0] || "0", 16);
+  const halves = text.split("::");
+  if (halves.length > 2) return undefined;
+  const parse = (part: string) =>
+    part === ""
+      ? []
+      : part.split(":").map((group) => Number.parseInt(group, 16));
+  const head = parse(halves[0]!);
+  const tail = halves.length === 2 ? parse(halves[1]!) : [];
+  const fill = 8 - head.length - tail.length;
+  if (halves.length === 1 ? fill !== 0 : fill < 1) return undefined;
+  const groups = [
+    ...head,
+    ...new Array<number>(halves.length === 2 ? fill : 0).fill(0),
+    ...tail,
+  ];
+  return groups.every((g) => Number.isInteger(g) && g >= 0 && g <= 0xffff)
+    ? groups
+    : undefined;
+}
+
+function v4From(high: number, low: number): string {
+  return `${high >> 8}.${high & 0xff}.${low >> 8}.${low & 0xff}`;
+}
+
+function isPrivateV6(address: string): boolean {
+  const g = expandV6(address);
+  if (!g) return true;
+  const zero = (from: number, to: number) =>
+    g.slice(from, to).every((x) => x === 0);
+  // ::/96 covers :: and ::1 and the deprecated IPv4-compatible form (::a.b.c.d).
+  if (zero(0, 6)) return true;
+  // ::ffff:0:0/96 IPv4-mapped: as private as the address it carries.
+  if (zero(0, 5) && g[5] === 0xffff) return isPrivateV4(v4From(g[6]!, g[7]!));
+  // 2002::/16 6to4 embeds an IPv4 address in bits 16..47.
+  if (g[0] === 0x2002) return isPrivateV4(v4From(g[1]!, g[2]!));
+  const first = g[0]!;
   return (
+    (first === 0x64 && g[1] === 0xff9b) || // 64:ff9b::/96 and 64:ff9b:1::/48 NAT64
+    (first === 0x100 && zero(1, 4)) || // 100::/64 discard
+    (first === 0x2001 && g[1] === 0) || // 2001::/32 Teredo (obfuscated IPv4)
+    (first === 0x2001 && g[1] === 0xdb8) || // 2001:db8::/32 documentation
     (first & 0xfe00) === 0xfc00 || // fc00::/7 unique local
     (first & 0xffc0) === 0xfe80 || // fe80::/10 link-local
-    (first & 0xff00) === 0xff00 || // ff00::/8 multicast
-    lower.startsWith("64:ff9b:") || // NAT64 well-known prefix
-    lower.startsWith("2001:db8:") // documentation
+    (first & 0xffc0) === 0xfec0 || // fec0::/10 deprecated site-local
+    (first & 0xff00) === 0xff00 // ff00::/8 multicast
   );
 }
 
@@ -136,12 +175,19 @@ export function admitUrl(raw: unknown): URL {
   return url;
 }
 
-async function assertPublicHost(url: URL, lookup: Lookup): Promise<void> {
+/**
+ * Check that a URL's host is public and return the address to connect to.
+ * Every resolved address must be public; the first one is returned so the
+ * request connects to exactly the address that was checked, never to a
+ * second, independent DNS answer (which a rebinding domain could point at
+ * loopback or a metadata service).
+ */
+async function assertPublicHost(url: URL, lookup: Lookup): Promise<string> {
   const host = url.hostname.replace(/^\[|\]$/g, "");
   if (isIP(host)) {
     if (isPrivateAddress(host))
       throw new WebError(`${host} is a private or local address`);
-    return;
+    return host;
   }
   let addresses: readonly string[];
   try {
@@ -153,6 +199,42 @@ async function assertPublicHost(url: URL, lookup: Lookup): Promise<void> {
   for (const address of addresses)
     if (isPrivateAddress(address))
       throw new WebError(`${host} resolves to a private or local address`);
+  return addresses[0]!;
+}
+
+/** Bun's fetch accepts TLS options beyond the standard RequestInit. */
+type PinnedInit = RequestInit & {
+  tls?: {
+    serverName?: string;
+    checkServerIdentity?: (
+      hostname: string,
+      cert: PeerCertificate,
+    ) => Error | undefined;
+  };
+};
+
+/**
+ * Address a request to a checked IP while keeping the original name for the
+ * Host header and for TLS (SNI and certificate verification), so the
+ * connection cannot be redirected by a later DNS answer.
+ */
+export function pinRequest(
+  url: URL,
+  address: string,
+): { target: string; host: string; tls?: PinnedInit["tls"] } {
+  const hostname = url.hostname.replace(/^\[|\]$/g, "");
+  const pinned = new URL(url.toString());
+  pinned.hostname = isIP(address) === 6 ? `[${address}]` : address;
+  const result: { target: string; host: string; tls?: PinnedInit["tls"] } = {
+    target: pinned.toString(),
+    host: url.host,
+  };
+  if (url.protocol === "https:" && !isIP(hostname))
+    result.tls = {
+      serverName: hostname,
+      checkServerIdentity: (_name, cert) => checkServerIdentity(hostname, cert),
+    };
+  return result;
 }
 
 export async function fetchUrl(
@@ -168,18 +250,22 @@ export async function fetchUrl(
     let url = admitUrl(raw);
     let response: Response | undefined;
     for (let hop = 0; hop <= FETCH_LIMITS.maxRedirects; hop += 1) {
-      await assertPublicHost(url, lookup);
+      const address = await assertPublicHost(url, lookup);
+      const pin = pinRequest(url, address);
+      const init: PinnedInit = {
+        method: "GET",
+        redirect: "manual",
+        headers: {
+          host: pin.host,
+          accept:
+            "text/html,application/xhtml+xml,text/plain;q=0.9,application/json;q=0.8,*/*;q=0.5",
+          "user-agent": "Mozilla/5.0 (compatible; dawg-agent)",
+        },
+        signal: timer.signal,
+      };
+      if (pin.tls) init.tls = pin.tls;
       try {
-        response = await fetcher(url, {
-          method: "GET",
-          redirect: "manual",
-          headers: {
-            accept:
-              "text/html,application/xhtml+xml,text/plain;q=0.9,application/json;q=0.8,*/*;q=0.5",
-            "user-agent": "Mozilla/5.0 (compatible; dawg-agent)",
-          },
-          signal: timer.signal,
-        });
+        response = await fetcher(pin.target, init);
       } catch (error) {
         throw new WebError(
           `fetch failed: ${timer.timedOut() ? `timed out after ${timeoutMs / 1000}s` : describeFetchError(error)}`,