@hraness/dawg 0.6.1 → 0.7.0

package/src/audio/instrument-check.ts

@@ -6,10 +6,12 @@
  * playing a test tone silently.
  */
 
+import { isGuideInstrument } from "../../core/clips.ts";
 import { isDrumInstrument } from "../../core/drums.ts";
 import { INSTRUMENT_WORDS, LEGACY_WORDS } from "../../core/instruments.ts";
 import { KEYS_FAMILIES } from "../../core/keys.ts";
 import { isSamplerInstrument, type Track } from "../../core/score.ts";
+import { nearest } from "../commands/nearest.ts";
 import { engineFor, registeredEngines } from "./instruments.ts";
 import { resolveOscillator } from "./synth/oscillators.ts";
 import { AVAILABLE_INSTRUMENTS } from "./wav.ts";
@@ -41,6 +43,24 @@ function knownWords(): readonly string[] {
   ];
 }
 
+/**
+ * `instrument list` rows: every exact instrument word, sorted, wrapped to
+ * `width` columns.
+ */
+export function instrumentListLines(width = 72): string[] {
+  const words = [...new Set(["sine", ...knownWords()])].sort();
+  const lines: string[] = [];
+  let line = "";
+  for (const word of words) {
+    if (line && line.length + 1 + word.length > width) {
+      lines.push(line);
+      line = word;
+    } else line = line ? `${line} ${word}` : word;
+  }
+  if (line) lines.push(line);
+  return lines;
+}
+
 /** Whether `instrument` (on `track`) renders as the plain sine fallback. */
 export function playsPlainSine(
   instrument: string,
@@ -54,6 +74,7 @@ export function playsPlainSine(
   if ((KEYS_FAMILIES as readonly string[]).includes(name)) return false;
   if (isDrumInstrument(name) || isSamplerInstrument(name)) return false;
   if (name === "wavetable" || resolveOscillator(name)) return false;
+  if (isGuideInstrument(name)) return false;
   return !LEGACY_TONES.some((tone) => name.includes(tone));
 }
 
@@ -73,22 +94,52 @@ export function plainSineAdvice(
     const advice = LEGACY_ADVICE[name];
     return `"${name}" is dawg's plain sine (kept for old projects)${advice ? ` · ${advice}` : ""}`;
   }
-  const near = nearestWord(name, knownWords());
   // A resolver word stored raw (an older project): the word itself now
   // picks a voice when typed again.
-  if (near === name)
+  if (knownWords().includes(name))
     return `"${name}" is stored as a bare word and plays a plain sine · type instrument ${name} again for its voice`;
+  const near = nearest(name, knownWords());
   return `"${name}" is not a dawg instrument and plays a plain sine${near ? ` · did you mean ${near}?` : ""}`;
 }
 
-/** Whether `word` is neither a known instrument nor a legacy word. */
+/**
+ * Whether `word` names an instrument exactly: an instrument word, preset,
+ * engine, keys family, oscillator, drum, sampler or guide word, or a legacy
+ * tone. The write path (`instrument <word>`) refuses anything else, so a typo
+ * such as `sawtoth` is never stored. Stored projects are not checked here:
+ * the read and render paths keep playing whatever they hold.
+ */
+export function isExactInstrument(word: string): boolean {
+  const name = word.trim().toLowerCase();
+  if (name === "") return false;
+  if (
+    name === "sine" ||
+    LEGACY_TONES.includes(name) ||
+    LEGACY_WORDS.includes(name) ||
+    knownWords().includes(name)
+  )
+    return true;
+  if (registeredEngines().includes(name)) return true;
+  if ((KEYS_FAMILIES as readonly string[]).includes(name)) return true;
+  if (isDrumInstrument(name) || isSamplerInstrument(name)) return true;
+  if (isGuideInstrument(name)) return true;
+  return name === "wavetable" || resolveOscillator(name) !== undefined;
+}
+
+/** Whether `word` is not an exact instrument name (see isExactInstrument). */
 export function isUnknownInstrument(word: string): boolean {
+  return !isExactInstrument(word);
+}
+
+/**
+ * `✗ instrument sawtoth · did you mean sawtooth? · instrument list`: the
+ * refusal for an instrument write that names nothing exactly.
+ */
+export function unknownInstrumentMessage(word: string): string {
   const name = word.trim().toLowerCase();
-  return (
-    playsPlainSine(name) &&
-    !LEGACY_WORDS.includes(name) &&
-    !INSTRUMENT_WORDS.some((row) => row.word === name)
-  );
+  const near = nearest(name, [...knownWords(), ...LEGACY_TONES, "sine"]);
+  const shown = name.length > 32 ? `${name.slice(0, 31)}…` : name;
+  return `instrument ${shown}${near ? ` · did you mean ${near}?` : ""} · instrument list`;
 }
 
 /** `dawg check` warnings for every track that plays the plain sine. */
@@ -100,38 +151,3 @@ export function plainSineWarnings(tracks: readonly Track[]): string[] {
   }
   return out;
 }
-
-/** The closest of `words` to `word` within two edits, if any. */
-export function nearestWord(
-  word: string,
-  words: readonly string[],
-): string | undefined {
-  let best: string | undefined;
-  let bestDistance = 3;
-  for (const candidate of words) {
-    const distance = editDistance(word, candidate);
-    if (distance < bestDistance) {
-      best = candidate;
-      bestDistance = distance;
-    }
-  }
-  return best;
-}
-
-function editDistance(a: string, b: string): number {
-  const row = Array.from({ length: b.length + 1 }, (_, index) => index);
-  for (let i = 1; i <= a.length; i += 1) {
-    let previous = row[0]!;
-    row[0] = i;
-    for (let j = 1; j <= b.length; j += 1) {
-      const saved = row[j]!;
-      row[j] = Math.min(
-        row[j]! + 1,
-        row[j - 1]! + 1,
-        previous + (a[i - 1] === b[j - 1] ? 0 : 1),
-      );
-      previous = saved;
-    }
-  }
-  return row[b.length]!;
-}

package/src/audio/instruments.ts

@@ -10,12 +10,14 @@ import type { PerformedNote } from "../../core/expression.ts";
 import type { Track, TrackScore } from "../../core/score.ts";
 import type { TuningTable } from "../../core/tuning.ts";
 import { WIND_ENGINE } from "./winds/engine.ts";
+import { SING_ENGINE } from "./sing/engine.ts";
 import { MODAL_ENGINE } from "./resonators.ts";
 import type { SampleBank } from "./samples.ts";
 import type { RenderContext } from "./wav.ts";
 import { STRING_ENGINE } from "./strings/engine.ts";
 import { GRANULAR_ENGINE } from "./granular.ts";
 import { KEYS_ENGINES } from "./keys/engine.ts";
+import { VOCODER_ENGINE } from "./vocoder/index.ts";
 
 /** What an engine renders with: the track's render context plus its tuning. */
 export type EngineContext = RenderContext &
@@ -138,3 +140,5 @@ registerEngine(GRANULAR_ENGINE);
 for (const engine of KEYS_ENGINES) registerEngine(engine);
 registerEngine(MODAL_ENGINE);
 registerEngine(WIND_ENGINE);
+registerEngine(SING_ENGINE);
+registerEngine(VOCODER_ENGINE);

package/src/audio/keys/calibration.ts

@@ -0,0 +1,56 @@
+/**
+ * Calibration 1 (q08): per-preset, key-tracked level trims for the keys
+ * engine and the harpsichord. The modelled pianos, electric pianos and
+ * clavs were levelled one family at a time, so at velocity 0.8 they sat 2
+ * to 40 dB under the `piano` synth and fell steeply up the keyboard (the
+ * hammer and tangent pulses filter the upper keys' partials hard). Each
+ * row is the gain in dB, fitted from renders, that brings one note at
+ * velocity 0.8 to the `piano` reference (-18 LUFS momentary maximum), at
+ * keys 24, 36, ... 108, capped so the note's sample peak stays at or under
+ * -4 dBFS; the top keys' hammer click is all crest, so there the cap wins
+ * and they sit a few dB under. Between keys the trim is interpolated in
+ * dB, and outside it holds the end value. Trims are linear, so velocity
+ * response is kept. Legacy songs (no calibration) never read this table.
+ *
+ * Pinned: never edit a row; a later revision appends a new table.
+ */
+export const KEYS_TRIM_KEYS = Object.freeze([
+  24, 36, 48, 60, 72, 84, 96, 108,
+] as const);
+
+/** Highest boost at any key, so the top octave is not pulled out of noise. */
+export const KEYS_TRIM_MAX_DB = 40;
+
+export const KEYS_TRIM_DB_1: Readonly<Record<string, readonly number[]>> =
+  Object.freeze({
+    harpsichord: [4.1, 7.0, 9.9, 13.1, 16.2, 18.6, 18.2, 17.5],
+    grand: [-1.4, -1.5, -0.6, 0.8, 3.8, 4.8, 5.5, 8.3],
+    ballad: [-4.1, -4.7, -3.4, -2.9, -0.5, 3.1, 5.4, 8.2],
+    upright: [1.4, 0.4, 0.5, 2.2, 4.0, 4.2, 4.8, 8.7],
+    felt: [3.9, 4.1, 4.5, 5.2, 6.6, 8.9, 10.6, 15.4],
+    lofi: [4.1, 4.1, 4.3, 5.7, 7.8, 8.2, 9.2, 15.0],
+    honkytonk: [1.2, 2.9, 3.2, 4.1, 4.0, 3.5, 3.6, 6.2],
+    prepared: [2.3, -1.5, 1.2, 5.7, 2.0, 6.2, 4.5, 7.6],
+    epiano: [6.0, 5.2, 4.8, 5.3, 7.3, 7.6, 6.5, 8.5],
+    suitcase: [7.6, 6.3, 5.6, 5.9, 7.7, 7.9, 6.6, 8.5],
+    dyno: [3.0, 4.1, 4.5, 5.1, 6.6, 7.5, 6.2, 7.7],
+    wurli: [9.6, 6.1, 5.3, 6.0, 7.8, 6.1, 7.6, 11.1],
+    clav: [8.1, 8.8, 8.9, 10.4, 11.2, 10.8, 8.5, 2.7],
+    funkclav: [7.1, 7.9, 9.0, 9.1, 9.0, 5.1, 7.8, 5.9],
+  });
+
+/** Linear gain for a preset at a key under calibration 1. */
+export function keysTrim(preset: string, key: number): number {
+  const row = KEYS_TRIM_DB_1[preset];
+  if (!row || row.length !== KEYS_TRIM_KEYS.length) return 1;
+  const keys = KEYS_TRIM_KEYS;
+  let db: number;
+  if (key <= keys[0]) db = row[0]!;
+  else if (key >= keys[keys.length - 1]!) db = row[row.length - 1]!;
+  else {
+    const i = Math.min(keys.length - 2, Math.floor((key - keys[0]) / 12));
+    const t = (key - keys[i]!) / 12;
+    db = row[i]! + (row[i + 1]! - row[i]!) * t;
+  }
+  return 10 ** (Math.min(KEYS_TRIM_MAX_DB, db) / 20);
+}

package/src/audio/keys/electric.ts

@@ -60,6 +60,8 @@ export type ElectricNoteOn = Readonly<{
   /** Track seed hash (clav pickup positions are per track). */
   trackSeed: number;
   noteSeed: string;
+  /** Song calibration (q08); 1+ keeps the tine hammer under the period. */
+  calibration?: number;
 }>;
 
 /** Clamped-free cantilever mode ratios. */
@@ -130,7 +132,12 @@ export class TineVoice implements KeysVoice {
     const drive = lerp(0.35, rhodes ? 1.6 : 1.5, p.bark);
     const A = (0.15 + 0.85 * v) * drive;
     // Hardness scales the hammer contact (0.5 is the prototype's).
-    const contact = lerp(2.2, 0.9, v) * (1.4 - 0.8 * p.hardness);
+    const legacy = lerp(2.2, 0.9, v) * (1.4 - 0.8 * p.hardness);
+    // Calibration 1: the contact stays under 0.6 of the tine's period, so
+    // the pulse's first null never lands under the fundamental (the top
+    // octave fell 35 dB).
+    const contact =
+      (note.calibration ?? 0) >= 1 ? Math.min(legacy, 600 / f) : legacy;
     this.pulse = hammerPulse(Math.max(2, Math.round(contact * 1e-3 * sr)), 1.5);
     this.bank = new ModeBank(4);
     this.bank.add(f, T, A * 0.85, 1, sr);

package/src/audio/keys/engine.ts

@@ -30,6 +30,7 @@ import { interpolateAutomation } from "../effects/common.ts";
 import type { EngineContext, InstrumentEngine } from "../instruments.ts";
 import { Biquad2, clamp, CONTROL, LN1000 } from "./dsp.ts";
 import { ORGAN_ENGINES } from "./organ.ts";
+import { keysTrim } from "./calibration.ts";
 import {
   damperT60,
   physicalKey,
@@ -154,6 +155,8 @@ export function bodyOf(values: Values): string {
 
 type Live = {
   voice: KeysVoice;
+  /** Calibration 1 level trim (1 for legacy songs). */
+  trim: number;
   /** Sample index the voice started at. */
   start: number;
   /** Sample index of key-up. */
@@ -216,6 +219,7 @@ export function renderKeysTrack(
   const seedTick = context.seedTick ?? 0;
   const window = Math.round(KEYS_LIMITS.tailSeconds * sr);
   const taper = Math.round(KEYS_LIMITS.taperSeconds * sr);
+  const calibrated = (context.score.calibration ?? 0) >= 1;
   const onsets: Onset[] = [];
   notes.forEach((note) => {
     const hz = noteHz(note.pitch, note.cents, context.tuning);
@@ -267,7 +271,14 @@ export function renderKeysTrack(
         trackSeed,
         noteSeed: `${track.id}:${note.id}:${note.startTick + seedTick}`,
         ...(soft > 0 ? { soft } : {}),
+        ...(calibrated ? { calibration: 1 } : {}),
       };
+      const trim = calibrated
+        ? keysTrim(
+            track.keys?.preset ?? track.instrument ?? "grand",
+            note.pitch,
+          )
+        : 1;
       const voice: KeysVoice = electric
         ? electricVoice(
             noteOn,
@@ -292,6 +303,7 @@ export function renderKeysTrack(
         bend && wow ? (t: number) => bend(t) + wow(t) : (bend ?? wow);
       live.push({
         voice,
+        trim,
         start: onset.start,
         off: onset.off,
         end: onset.off + window,
@@ -331,7 +343,7 @@ export function renderKeysTrack(
           gain *= Math.max(0, x.fade) / x.fadeLength;
           x.fade -= 1;
         }
-        const y = block[s]! * gain;
+        const y = block[s]! * gain * x.trim;
         left[index]! += y * gl;
         right[index]! += y * gr;
       }

package/src/audio/keys/piano.ts

@@ -162,6 +162,11 @@ export type PianoNoteOn = Readonly<{
    * the unstruck string's aftersound.
    */
   soft?: number;
+  /**
+   * Song calibration (q08); 1+ keeps the hammer contact shorter than the
+   * fundamental's period and levels on what the hammer excites.
+   */
+  calibration?: number;
 }>;
 
 type Rattle = {
@@ -242,8 +247,13 @@ export class PianoVoice {
           )
         : 1;
     if (soft > 0) after = clamp(after + (1 - after) * 0.4 * soft, 0, 0.95);
+    const calibrated = (note.calibration ?? 0) >= 1;
+    // Calibration 1: a contact longer than about 0.6 of the fundamental's
+    // period puts the pulse's first spectral null under partial 1, and
+    // the upper keys came out as hammer noise (40 dB down at C7).
+    const contactMs = calibrated ? Math.min(thMs, 600 / f1) : thMs;
     this.pulse = hammerPulse(
-      Math.max(2, Math.round(thMs * 1e-3 * sr)),
+      Math.max(2, Math.round(contactMs * 1e-3 * sr)),
       1 + 2 * v * p.hardness,
     );
     const strings = stringsFor(key);
@@ -311,10 +321,20 @@ export class PianoVoice {
     // amplitude) is made up so the extra loss stays about 1 dB.
     if (soft > 0)
       loud *= (1 - 0.3 * soft) * Math.sqrt(sum0 / Math.max(sumW, 1e-9));
-    const G = (0.35 * loud) / Math.sqrt(Math.max(energy, 1e-9));
     const mags = candidates.map(
       (c) => pulseMag(this.pulse, (TAU * c.hz) / sr) * Math.abs(c.u),
     );
+    // Calibration 1 levels on the partials the hammer actually excites
+    // (as the electric keys do), so the hammer filter no longer sets the
+    // level; legacy levels on the unfiltered strike.
+    const heard = calibrated
+      ? mags.reduce((sum, m) => sum + m * m, 0) /
+        Math.max(
+          1e-12,
+          candidates.reduce((sum, c) => sum + c.u * c.u, 0),
+        )
+      : 1;
+    const G = (0.35 * loud) / Math.sqrt(Math.max(energy * heard, 1e-9));
     const peak = Math.max(0, ...mags);
     candidates.forEach((c, i) => {
       // Below -80 dB after the hammer filter: not worth a mode.

package/src/audio/kits.ts

@@ -7,7 +7,7 @@
  * arithmetic on the seeded noise `wav.ts` passes in, so a kit renders the
  * same buffer on every run.
  */
-import type { DrumVoice } from "../../core/drums.ts";
+import { type DrumVoice, isDrumInstrument } from "../../core/drums.ts";
 import {
   SYNTH_KITS,
   type DrumBodyParams,
@@ -48,9 +48,10 @@ function body(
   noise: number,
   state: KitVoiceState,
   sampleRate: number,
+  ratio = 1,
 ): number {
   const frequency =
-    params.base + params.sweep * Math.exp(-t * params.sweepRate);
+    (params.base + params.sweep * Math.exp(-t * params.sweepRate)) * ratio;
   state.phase += frequency / sampleRate;
   return (
     Math.sin(2 * Math.PI * state.phase) *
@@ -60,19 +61,52 @@ function body(
   );
 }
 
+/** PolyBLEP residual for a unit step at phase 0 (Välimäki). */
+function polyBlep(phase: number, step: number): number {
+  if (phase < step) {
+    const x = phase / step;
+    return x + x - x * x - 1;
+  }
+  if (phase > 1 - step) {
+    const x = (phase - 1) / step;
+    return x * x + x + x + 1;
+  }
+  return 0;
+}
+
+/** A band-limited square at `hz`, `t` seconds in (closed-form phase). */
+export function blepSquare(hz: number, t: number, sampleRate: number): number {
+  const phase = (t * hz) % 1;
+  const step = Math.min(0.5, hz / sampleRate);
+  return (
+    (phase < 0.5 ? 1 : -1) +
+    polyBlep(phase, step) -
+    polyBlep((phase + 0.5) % 1, step)
+  );
+}
+
 function hat(
   params: HatParams,
   t: number,
   noise: number,
   bright: number,
   state: KitVoiceState,
+  sampleRate = 0,
 ): number {
   state.dark += 0.3 * (noise - state.dark);
   const noisy = params.tone * bright + (1 - params.tone) * state.dark * 0.8;
   let source = noisy;
   if (params.metal > 0) {
     let square = 0;
-    for (const hz of METAL_HZ) square += (t * hz) % 1 < 0.5 ? 1 : -1;
+    // Calibrated (sampleRate > 0): band-limited squares, so the metal
+    // does not alias and sounds the same at every rate.
+    for (const hz of METAL_HZ)
+      square +=
+        sampleRate > 0
+          ? blepSquare(hz, t, sampleRate)
+          : (t * hz) % 1 < 0.5
+            ? 1
+            : -1;
     // First difference: keep the metallic top end, drop the low beating.
     const metal = (square / METAL_HZ.length - state.metalPrevious) * 1.6;
     state.metalPrevious = square / METAL_HZ.length;
@@ -90,10 +124,21 @@ export function kitDrumSample(
   bright: number,
   state: KitVoiceState,
   sampleRate: number,
+  /** Calibration 1+ (0.7): pitch ratio for toms, band-limited metal. */
+  calibrated?: Readonly<{ tomRatio: number }>,
 ): number {
   let sample: number;
+  const metalRate = calibrated ? sampleRate : 0;
   if (voice === "kick") sample = body(kit.kick, t, noise, state, sampleRate);
-  else if (voice === "tom") sample = body(kit.tom, t, noise, state, sampleRate);
+  else if (voice === "tom")
+    sample = body(
+      kit.tom,
+      t,
+      noise,
+      state,
+      sampleRate,
+      calibrated?.tomRatio ?? 1,
+    );
   else if (voice === "snare") {
     const p = kit.snare;
     state.phase += p.tone / sampleRate;
@@ -112,9 +157,10 @@ export function kitDrumSample(
       state.band *
       p.level *
       (burst + 0.8 * Math.exp(-(t - span) * p.tail) * +(t >= span));
-  } else if (voice === "hat") sample = hat(kit.hat, t, noise, bright, state);
+  } else if (voice === "hat")
+    sample = hat(kit.hat, t, noise, bright, state, metalRate);
   else if (voice === "openhat")
-    sample = hat(kit.openhat, t, noise, bright, state);
+    sample = hat(kit.openhat, t, noise, bright, state, metalRate);
   else {
     const p = kit.rim;
     sample =
@@ -142,9 +188,92 @@ export function kitDrumSample(
   return sample * kit.gain;
 }
 
+// ── calibrated GM extras (0.7) ─────────────────────────────────────────
+
+/** GM cymbal and bell numbers that calibration 1+ plays as metal. */
+export type MetalKind = "crash" | "ride" | "cowbell";
+
+const METAL_PITCHES: Readonly<Record<number, MetalKind>> = Object.freeze({
+  49: "crash",
+  52: "crash",
+  55: "crash",
+  57: "crash",
+  51: "ride",
+  53: "ride",
+  59: "ride",
+  56: "cowbell",
+});
+
+/** The metal voice for a GM pitch, or undefined for every other number. */
+export function metalKindForPitch(pitch: number): MetalKind | undefined {
+  return METAL_PITCHES[pitch];
+}
+
+/**
+ * GM tom pitch ratio: 45 (low tom) is the voice's own tuning, and each GM
+ * semitone moves the body by two thirds of a semitone, so 41 (low floor)
+ * through 50 (high tom) spread across about half an octave.
+ */
+export function tomRatio(pitch: number): number {
+  const clamped = Math.max(35, Math.min(55, pitch));
+  return 2 ** (((clamped - 45) * 2) / 3 / 12);
+}
+
+/**
+ * One sample of a crash, ride or cowbell, `t` seconds after the hit.
+ * Crash and ride are band-limited inharmonic squares through a first
+ * difference plus bright noise; the cowbell is the classic 540/800 Hz
+ * square pair. Deterministic: closed-form phase and the caller's noise.
+ */
+export function metalSample(
+  kind: MetalKind,
+  t: number,
+  bright: number,
+  state: KitVoiceState,
+  sampleRate: number,
+): number {
+  if (kind === "cowbell") {
+    const tone =
+      (blepSquare(540, t, sampleRate) + blepSquare(800, t, sampleRate)) / 2;
+    state.band += 0.45 * (tone - state.band);
+    const envelope = 0.7 * Math.exp(-t * 60) + 0.3 * Math.exp(-t * 9);
+    return state.band * 0.5 * envelope;
+  }
+  let square = 0;
+  for (const hz of METAL_HZ) square += blepSquare(hz * 1.9, t, sampleRate);
+  const metal = (square / METAL_HZ.length - state.metalPrevious) * 1.6;
+  state.metalPrevious = square / METAL_HZ.length;
+  if (kind === "crash") {
+    const swell = Math.min(1, t / 0.004);
+    return (0.55 * bright + 0.45 * metal) * 0.42 * swell * Math.exp(-t * 4.2);
+  }
+  // Ride: a pinged bell over a long, quieter wash.
+  const ping = (0.6 * metal + 0.4 * bright) * 0.3 * Math.exp(-t * 28);
+  const wash = (0.35 * metal + 0.65 * bright) * 0.16 * Math.exp(-t * 3.5);
+  return ping + wash;
+}
+
+/** Length of a calibrated crash, ride or cowbell one-shot. */
+export const METAL_SECONDS = 1.4;
+
 /** Longest synth-kit one-shot in the score; 0 without kits (so renders without kits are unchanged). */
 export function kitTailSeconds(score: TrackScore): number {
   let seconds = 0;
+  if ((score.calibration ?? 0) >= 1) {
+    const drums = new Set(
+      score.tracks
+        .filter((track) => isDrumInstrument(track.instrument))
+        .map((track) => track.id),
+    );
+    if (
+      score.notes.some(
+        (note) =>
+          drums.has(note.trackId) &&
+          metalKindForPitch(note.pitch) !== undefined,
+      )
+    )
+      seconds = METAL_SECONDS;
+  }
   for (const track of score.tracks)
     seconds = Math.max(seconds, synthKit(track.kit)?.seconds ?? 0);
   return seconds;