@octoseq/mir 0.1.0-main.2e286ce → 0.1.0-main.4baa7cd

package/src/dsp/tempoHypotheses.ts

@@ -0,0 +1,395 @@
+import type { BeatCandidate, TempoHypothesis, TempoHypothesisEvidence } from "../types";
+
+/**
+ * Configuration for tempo hypothesis generation.
+ */
+export type TempoHypothesesOptions = {
+    /** Minimum BPM to consider. Default: 24. */
+    minBpm?: number;
+    /** Maximum BPM to consider. Default: 300. */
+    maxBpm?: number;
+    /** Histogram bin size in BPM. Default: 1.0. */
+    binSizeBpm?: number;
+    /** Maximum hypotheses to return. Default: 10. */
+    maxHypotheses?: number;
+    /** Minimum confidence threshold (0-1). Default: 0.05. */
+    minConfidence?: number;
+    /** Weight IOIs by candidate strength. Default: true. */
+    weightByStrength?: boolean;
+    /** Include histogram data in output. Default: false. */
+    includeHistogram?: boolean;
+};
+
+export type TempoHypothesesOutput = {
+    hypotheses: TempoHypothesis[];
+    inputCandidateCount: number;
+    histogram?: {
+        bpmBins: Float32Array;
+        counts: Float32Array;
+    };
+};
+
+/**
+ * Convert interval (seconds) to BPM.
+ */
+function intervalToBpm(intervalSec: number): number {
+    return 60.0 / intervalSec;
+}
+
+/**
+ * Convert BPM to interval (seconds).
+ */
+function bpmToInterval(bpm: number): number {
+    return 60.0 / bpm;
+}
+
+type IOI = { intervalSec: number; weight: number };
+
+/**
+ * Compute inter-onset intervals from beat candidates.
+ *
+ * @param candidates - Beat candidates sorted by time
+ * @param weightByStrength - Whether to weight by candidate strength
+ * @returns Array of { intervalSec, weight } pairs
+ */
+function computeIOIs(candidates: BeatCandidate[], weightByStrength: boolean): IOI[] {
+    if (candidates.length < 2) return [];
+
+    const iois: IOI[] = [];
+
+    // Sort candidates by time (should already be sorted, but be defensive)
+    const sorted = [...candidates].sort((a, b) => a.time - b.time);
+
+    for (let i = 1; i < sorted.length; i++) {
+        const prev = sorted[i - 1]!;
+        const curr = sorted[i]!;
+        const interval = curr.time - prev.time;
+
+        // Skip invalid intervals
+        if (interval <= 0) continue;
+
+        // Weight is geometric mean of adjacent strengths, or 1.0 if not weighting
+        const weight = weightByStrength
+            ? Math.sqrt(prev.strength * curr.strength)
+            : 1.0;
+
+        iois.push({ intervalSec: interval, weight });
+    }
+
+    return iois;
+}
+
+/**
+ * Build a weighted histogram of BPM values from IOIs.
+ *
+ * @param iois - Inter-onset intervals with weights
+ * @param minBpm - Minimum BPM (determines max interval)
+ * @param maxBpm - Maximum BPM (determines min interval)
+ * @param binSizeBpm - Size of each histogram bin in BPM
+ * @returns { bins: center BPM of each bin, counts: weighted counts }
+ */
+function buildBpmHistogram(
+    iois: IOI[],
+    minBpm: number,
+    maxBpm: number,
+    binSizeBpm: number
+): { bpmBins: Float32Array; counts: Float32Array } {
+    const numBins = Math.ceil((maxBpm - minBpm) / binSizeBpm);
+    const counts = new Float32Array(numBins);
+    const bpmBins = new Float32Array(numBins);
+
+    // Initialize bin centers
+    for (let i = 0; i < numBins; i++) {
+        bpmBins[i] = minBpm + (i + 0.5) * binSizeBpm;
+    }
+
+    // Convert interval range to BPM range
+    const minInterval = bpmToInterval(maxBpm);
+    const maxInterval = bpmToInterval(minBpm);
+
+    for (const { intervalSec, weight } of iois) {
+        // Filter to plausible range
+        if (intervalSec < minInterval || intervalSec > maxInterval) continue;
+
+        const bpm = intervalToBpm(intervalSec);
+        const binIndex = Math.floor((bpm - minBpm) / binSizeBpm);
+
+        if (binIndex >= 0 && binIndex < numBins) {
+            counts[binIndex] = (counts[binIndex] ?? 0) + weight;
+        }
+    }
+
+    return { bpmBins, counts };
+}
+
+/**
+ * Find peaks in the histogram using local maximum detection.
+ *
+ * @param counts - Weighted counts per bin
+ * @param minHeight - Minimum peak height (absolute)
+ * @returns Array of peak indices sorted by height descending
+ */
+function findHistogramPeaks(counts: Float32Array, minHeight: number): number[] {
+    const peaks: Array<{ index: number; height: number }> = [];
+
+    for (let i = 1; i < counts.length - 1; i++) {
+        const curr = counts[i]!;
+        const prev = counts[i - 1]!;
+        const next = counts[i + 1]!;
+
+        // Local maximum
+        if (curr > prev && curr > next && curr >= minHeight) {
+            peaks.push({ index: i, height: curr });
+        }
+    }
+
+    // Also check boundary bins if they're high enough
+    if (counts.length > 0 && counts[0]! >= minHeight && counts[0]! > (counts[1] ?? 0)) {
+        peaks.push({ index: 0, height: counts[0]! });
+    }
+    if (counts.length > 1) {
+        const last = counts.length - 1;
+        if (counts[last]! >= minHeight && counts[last]! > (counts[last - 1] ?? 0)) {
+            peaks.push({ index: last, height: counts[last]! });
+        }
+    }
+
+    // Sort by height descending
+    peaks.sort((a, b) => b.height - a.height);
+
+    return peaks.map((p) => p.index);
+}
+
+/**
+ * Merge adjacent peak bins to get refined BPM estimate.
+ * Uses weighted centroid of adjacent bins.
+ */
+function refinePeakBpm(
+    peakIndex: number,
+    bpmBins: Float32Array,
+    counts: Float32Array,
+    binSizeBpm: number
+): { bpm: number; peakHeight: number; binRange: [number, number]; totalWeight: number } {
+    // Consider the peak bin and immediate neighbors
+    let totalWeight = 0;
+    let weightedBpm = 0;
+    let minBinBpm = bpmBins[peakIndex]! - binSizeBpm / 2;
+    let maxBinBpm = bpmBins[peakIndex]! + binSizeBpm / 2;
+
+    for (let offset = -1; offset <= 1; offset++) {
+        const idx = peakIndex + offset;
+        if (idx < 0 || idx >= bpmBins.length) continue;
+
+        const w = counts[idx]!;
+        const bpm = bpmBins[idx]!;
+
+        totalWeight += w;
+        weightedBpm += w * bpm;
+
+        if (w > 0) {
+            minBinBpm = Math.min(minBinBpm, bpm - binSizeBpm / 2);
+            maxBinBpm = Math.max(maxBinBpm, bpm + binSizeBpm / 2);
+        }
+    }
+
+    const refinedBpm = totalWeight > 0 ? weightedBpm / totalWeight : bpmBins[peakIndex]!;
+
+    return {
+        bpm: refinedBpm,
+        peakHeight: counts[peakIndex]!,
+        binRange: [minBinBpm, maxBinBpm],
+        totalWeight,
+    };
+}
+
+/**
+ * Check if two BPMs are harmonically related (within tolerance).
+ * Returns the harmonic ratio if related, null otherwise.
+ */
+function getHarmonicRatio(bpm1: number, bpm2: number, tolerance: number = 0.03): number | null {
+    const ratios = [0.5, 1 / 3, 2 / 3, 1.0, 1.5, 2.0, 3.0];
+
+    for (const ratio of ratios) {
+        const expected = bpm1 * ratio;
+        const relativeError = Math.abs(bpm2 - expected) / expected;
+        if (relativeError <= tolerance) {
+            return ratio;
+        }
+    }
+
+    return null;
+}
+
+/**
+ * Group hypotheses into harmonic families.
+ * Assigns familyId and harmonicRatio to each hypothesis.
+ *
+ * Uses deterministic family IDs based on the root BPM.
+ */
+function assignHarmonicFamilies(hypotheses: TempoHypothesis[]): void {
+    if (hypotheses.length === 0) return;
+
+    const families: Map<string, { rootBpm: number; members: TempoHypothesis[] }> = new Map();
+
+    for (const hyp of hypotheses) {
+        let foundFamily = false;
+
+        for (const [familyId, family] of families) {
+            const ratio = getHarmonicRatio(family.rootBpm, hyp.bpm);
+            if (ratio !== null) {
+                hyp.familyId = familyId;
+                hyp.harmonicRatio = ratio;
+                family.members.push(hyp);
+                foundFamily = true;
+                break;
+            }
+        }
+
+        if (!foundFamily) {
+            // Create new family with this hypothesis as root
+            // Use deterministic family ID based on root BPM
+            const familyId = `fam-${Math.round(hyp.bpm)}`;
+            hyp.familyId = familyId;
+            hyp.harmonicRatio = 1.0;
+            families.set(familyId, { rootBpm: hyp.bpm, members: [hyp] });
+        }
+    }
+}
+
+/**
+ * Normalize confidence scores to [0, 1] range.
+ */
+function normalizeConfidence(hypotheses: TempoHypothesis[]): void {
+    if (hypotheses.length === 0) return;
+
+    const maxHeight = Math.max(...hypotheses.map((h) => h.evidence.peakHeight));
+    if (maxHeight <= 0) return;
+
+    for (const hyp of hypotheses) {
+        hyp.confidence = hyp.evidence.peakHeight / maxHeight;
+    }
+}
+
+/**
+ * Generate tempo hypotheses from beat candidates.
+ *
+ * Algorithm:
+ * 1. Compute inter-onset intervals (IOIs) from beat candidates
+ * 2. Filter IOIs to musically plausible range (0.2s-2.5s -> 24-300 BPM)
+ * 3. Build weighted histogram with configurable bin size
+ * 4. Extract peaks as tempo candidates
+ * 5. Refine BPM estimates using weighted centroid
+ * 6. Group into harmonic families
+ * 7. Normalize confidence scores
+ *
+ * @param candidates - Beat candidates from B1
+ * @param options - Configuration options
+ * @returns Tempo hypotheses with confidence and family groupings
+ */
+export function generateTempoHypotheses(
+    candidates: BeatCandidate[],
+    options?: TempoHypothesesOptions
+): TempoHypothesesOutput {
+    const minBpm = options?.minBpm ?? 24;
+    const maxBpm = options?.maxBpm ?? 300;
+    const binSizeBpm = options?.binSizeBpm ?? 1.0;
+    const maxHypotheses = options?.maxHypotheses ?? 10;
+    const minConfidence = options?.minConfidence ?? 0.05;
+    const weightByStrength = options?.weightByStrength ?? true;
+    const includeHistogram = options?.includeHistogram ?? false;
+
+    // Early return if insufficient candidates
+    if (candidates.length < 2) {
+        return {
+            hypotheses: [],
+            inputCandidateCount: candidates.length,
+            histogram: includeHistogram
+                ? {
+                      bpmBins: new Float32Array(0),
+                      counts: new Float32Array(0),
+                  }
+                : undefined,
+        };
+    }
+
+    // Step 1: Compute IOIs
+    const iois = computeIOIs(candidates, weightByStrength);
+
+    if (iois.length === 0) {
+        return {
+            hypotheses: [],
+            inputCandidateCount: candidates.length,
+            histogram: includeHistogram
+                ? {
+                      bpmBins: new Float32Array(0),
+                      counts: new Float32Array(0),
+                  }
+                : undefined,
+        };
+    }
+
+    // Step 2-3: Build histogram (filtering happens during binning)
+    const { bpmBins, counts } = buildBpmHistogram(iois, minBpm, maxBpm, binSizeBpm);
+
+    // Calculate minimum height threshold based on minConfidence
+    const maxCount = Math.max(...counts);
+    const minHeight = maxCount * minConfidence;
+
+    // Step 4: Find peaks
+    const peakIndices = findHistogramPeaks(counts, minHeight);
+
+    // Step 5: Create hypotheses with refined BPM
+    const hypotheses: TempoHypothesis[] = [];
+
+    for (const peakIndex of peakIndices.slice(0, maxHypotheses * 2)) {
+        // Get extra for filtering
+        const { bpm, peakHeight, binRange, totalWeight } = refinePeakBpm(
+            peakIndex,
+            bpmBins,
+            counts,
+            binSizeBpm
+        );
+
+        // Skip if below confidence threshold
+        if (maxCount > 0 && peakHeight / maxCount < minConfidence) continue;
+
+        const evidence: TempoHypothesisEvidence = {
+            supportingIntervalCount: Math.round(totalWeight),
+            weightedSupport: totalWeight,
+            peakHeight,
+            binRange,
+        };
+
+        hypotheses.push({
+            id: "", // Will be assigned after sorting
+            bpm: Math.round(bpm * 10) / 10, // Round to 0.1 BPM precision
+            confidence: 0, // Will be normalized
+            evidence,
+            familyId: "", // Will be assigned
+            harmonicRatio: 1.0, // Will be assigned
+        });
+    }
+
+    // Step 6: Group into harmonic families
+    assignHarmonicFamilies(hypotheses);
+
+    // Step 7: Normalize confidence
+    normalizeConfidence(hypotheses);
+
+    // Filter by minConfidence and sort by confidence descending
+    const filtered = hypotheses
+        .filter((h) => h.confidence >= minConfidence)
+        .sort((a, b) => b.confidence - a.confidence)
+        .slice(0, maxHypotheses);
+
+    // Assign deterministic IDs based on rank
+    for (let i = 0; i < filtered.length; i++) {
+        filtered[i]!.id = `hyp-${i}`;
+    }
+
+    return {
+        hypotheses: filtered,
+        inputCandidateCount: candidates.length,
+        histogram: includeHistogram ? { bpmBins, counts } : undefined,
+    };
+}

package/src/index.ts

@@ -9,7 +9,13 @@ export type {
   MirResult,
   MirFunctionId,
   MirRunRequest,
-  MirAudioPayload
+  MirAudioPayload,
+  BeatCandidate,
+  BeatCandidateSource,
+  BeatCandidatesResult,
+  TempoHypothesis,
+  TempoHypothesisEvidence,
+  TempoHypothesesResult,
 } from "./types";
 
 export const MIR_VERSION: MirVersion = "0.1.0";
@@ -59,6 +65,20 @@ export { onsetEnvelopeFromSpectrogram, onsetEnvelopeFromMel, onsetEnvelopeFromMe
 export type { PeakPickEvent, PeakPickOptions } from "./dsp/peakPick";
 export { peakPick } from "./dsp/peakPick";
 
+// ----------------------------
+// Beat Candidates
+// ----------------------------
+
+export type { BeatCandidatesOptions, BeatCandidatesOutput, BeatSalienceSignal } from "./dsp/beatCandidates";
+export { detectBeatCandidates, beatSalienceFromMel } from "./dsp/beatCandidates";
+
+// ----------------------------
+// Tempo Hypotheses
+// ----------------------------
+
+export type { TempoHypothesesOptions, TempoHypothesesOutput } from "./dsp/tempoHypotheses";
+export { generateTempoHypotheses } from "./dsp/tempoHypotheses";
+
 // ----------------------------
 // HPSS
 // ----------------------------

package/src/runner/runMir.ts

@@ -1,3 +1,5 @@
+import { detectBeatCandidates } from "../dsp/beatCandidates";
+import { generateTempoHypotheses } from "../dsp/tempoHypotheses";
 import { melSpectrogram, type MelConfig, type MelSpectrogram } from "../dsp/mel";
 import { mfcc, delta, deltaDelta } from "../dsp/mfcc";
 import { onsetEnvelopeFromMel, onsetEnvelopeFromMelGpu } from "../dsp/onset";
@@ -285,6 +287,76 @@ export async function runMir(
         };
     }
 
+    if (request.fn === "beatCandidates") {
+        // Beat candidate detection requires both mel spectrogram and raw spectrogram.
+        const { mel, cpuExtraMs: melCpuMs } = await computeMel(false);
+
+        const beatOpts = request.beatCandidates ?? {};
+        const result = detectBeatCandidates(mel, spec, {
+            minIntervalSec: beatOpts.minIntervalSec,
+            thresholdFactor: beatOpts.thresholdFactor,
+            smoothMs: beatOpts.smoothMs,
+        });
+
+        const end = nowMs();
+        return {
+            kind: "beatCandidates",
+            times: result.salience.times,
+            candidates: result.candidates,
+            salience: beatOpts.includeSalience ? result.salience : undefined,
+            meta: {
+                backend: "cpu",
+                usedGpu: false,
+                timings: {
+                    totalMs: end - t0,
+                    cpuMs: cpuAfterSpec - cpuStart + melCpuMs,
+                },
+            },
+        };
+    }
+
+    if (request.fn === "tempoHypotheses") {
+        // Tempo hypothesis generation requires beat candidates.
+        // We compute them internally (could accept pre-computed in future).
+        const { mel, cpuExtraMs: melCpuMs } = await computeMel(false);
+
+        const beatOpts = request.beatCandidates ?? {};
+        const beatResult = detectBeatCandidates(mel, spec, {
+            minIntervalSec: beatOpts.minIntervalSec,
+            thresholdFactor: beatOpts.thresholdFactor,
+            smoothMs: beatOpts.smoothMs,
+        });
+
+        const tempoStart = nowMs();
+        const tempoOpts = request.tempoHypotheses ?? {};
+        const result = generateTempoHypotheses(beatResult.candidates, {
+            minBpm: tempoOpts.minBpm,
+            maxBpm: tempoOpts.maxBpm,
+            binSizeBpm: tempoOpts.binSizeBpm,
+            maxHypotheses: tempoOpts.maxHypotheses,
+            minConfidence: tempoOpts.minConfidence,
+            weightByStrength: tempoOpts.weightByStrength,
+            includeHistogram: tempoOpts.includeHistogram,
+        });
+
+        const end = nowMs();
+        return {
+            kind: "tempoHypotheses",
+            times: spec.times,
+            hypotheses: result.hypotheses,
+            inputCandidateCount: result.inputCandidateCount,
+            histogram: result.histogram,
+            meta: {
+                backend: "cpu",
+                usedGpu: false,
+                timings: {
+                    totalMs: end - t0,
+                    cpuMs: cpuAfterSpec - cpuStart + melCpuMs + (end - tempoStart),
+                },
+            },
+        };
+    }
+
     if (request.fn === "hpssHarmonic" || request.fn === "hpssPercussive") {
         // HPSS may use a custom spectrogram config
         const hpssSpecConfig = options.hpss?.spectrogram ?? specConfig;

package/src/runner/workerProtocol.ts

@@ -1,4 +1,4 @@
-import type { MirAudioPayload, MirResult, MirRunRequest } from "../types";
+import type { BeatCandidate, MirAudioPayload, MirResult, MirRunRequest, TempoHypothesis } from "../types";
 
 export type MirWorkerInitMessage = {
     type: "INIT";
@@ -93,6 +93,14 @@ export type MirWorkerResultMessage = {
         values?: ArrayBufferLike;
         data2d?: ArrayBufferLike[];
         events?: Array<{ time: number; strength: number; index: number }>;
+        candidates?: BeatCandidate[];
+        // For tempoHypotheses
+        hypotheses?: TempoHypothesis[];
+        inputCandidateCount?: number;
+        histogram?: {
+            bpmBins: ArrayBufferLike;
+            counts: ArrayBufferLike;
+        };
         meta: MirResult["meta"];
     };
 };

package/src/types.ts

@@ -39,7 +39,97 @@ export type MirEventsResult = {
     meta: MirRunMeta;
 };
 
-export type MirResult = Mir1DResult | Mir2DResult | MirEventsResult;
+/**
+ * A beat candidate represents a plausible beat-like moment in the audio.
+ *
+ * These are sparse events (timestamps) that may or may not correspond to
+ * actual beats. They are not tempo-aligned and do not imply any BPM value.
+ *
+ * Beat candidates are intended to be:
+ * - Dense enough to include most true beats
+ * - Sparse enough to be computationally tractable
+ * - Inspectable in the UI for debugging
+ *
+ * Future milestones will cluster, align, and refine these candidates.
+ */
+export type BeatCandidate = {
+    /** Time in seconds from track start. */
+    time: number;
+    /** Relative salience/confidence (0-1 normalized). Higher = more likely to be a beat. */
+    strength: number;
+    /** Source of this candidate (for debugging/inspection). */
+    source: BeatCandidateSource;
+};
+
+export type BeatCandidateSource =
+    | "onset_peak"      // Derived from onset envelope peaks
+    | "flux_peak"       // Derived from spectral flux peaks
+    | "combined";       // Derived from combined salience signal
+
+export type BeatCandidatesResult = {
+    kind: "beatCandidates";
+    /** Frame times from the underlying analysis (for alignment). */
+    times: Float32Array;
+    /** The beat candidate events. */
+    candidates: BeatCandidate[];
+    /** Optional: the salience signal used for peak picking (for debugging). */
+    salience?: {
+        times: Float32Array;
+        values: Float32Array;
+    };
+    meta: MirRunMeta;
+};
+
+/**
+ * A tempo hypothesis represents a plausible BPM with confidence score.
+ *
+ * Hypotheses are derived from inter-onset intervals of beat candidates.
+ * They are grouped into harmonic families (e.g., 60, 120, 180 BPM) but
+ * not collapsed - each BPM is preserved as a separate hypothesis.
+ */
+export type TempoHypothesis = {
+    /** Deterministic identifier for this hypothesis (e.g., "hyp-0"). */
+    id: string;
+    /** Tempo in beats per minute (0.1 BPM precision). */
+    bpm: number;
+    /** Confidence score normalized to [0, 1]. Higher = more likely. */
+    confidence: number;
+    /** Evidence metadata for debugging/inspection. */
+    evidence: TempoHypothesisEvidence;
+    /** Harmonic family ID - hypotheses in the same family are harmonically related. */
+    familyId: string;
+    /** Harmonic relationship to the family root (1.0 = root, 2.0 = double, 0.5 = half, etc.). */
+    harmonicRatio: number;
+};
+
+export type TempoHypothesisEvidence = {
+    /** Number of IOIs supporting this tempo. */
+    supportingIntervalCount: number;
+    /** Sum of weighted contributions (if strength-weighting enabled). */
+    weightedSupport: number;
+    /** Peak height in the histogram. */
+    peakHeight: number;
+    /** Histogram bin range [minBpm, maxBpm]. */
+    binRange: [number, number];
+};
+
+export type TempoHypothesesResult = {
+    kind: "tempoHypotheses";
+    /** Frame times from underlying analysis (for alignment). */
+    times: Float32Array;
+    /** Ordered list of tempo hypotheses (by confidence descending). */
+    hypotheses: TempoHypothesis[];
+    /** The number of beat candidates used as input. */
+    inputCandidateCount: number;
+    /** Histogram data for debugging/visualization. */
+    histogram?: {
+        bpmBins: Float32Array;
+        counts: Float32Array;
+    };
+    meta: MirRunMeta;
+};
+
+export type MirResult = Mir1DResult | Mir2DResult | MirEventsResult | BeatCandidatesResult | TempoHypothesesResult;
 
 // (moved above)
 
@@ -49,6 +139,8 @@ export type MirFunctionId =
     | "melSpectrogram"
     | "onsetEnvelope"
     | "onsetPeaks"
+    | "beatCandidates"
+    | "tempoHypotheses"
     | "hpssHarmonic"
     | "hpssPercussive"
     | "mfcc"
@@ -97,6 +189,32 @@ export type MirRunRequest = {
             window: "hann";
         };
     };
+    beatCandidates?: {
+        /** Minimum inter-candidate interval in seconds. Default: 0.1 (100ms). */
+        minIntervalSec?: number;
+        /** Threshold factor for peak detection. Lower = more candidates. Default: 0.5. */
+        thresholdFactor?: number;
+        /** Smoothing window for salience signal in ms. Default: 50. */
+        smoothMs?: number;
+        /** Whether to include the salience signal in output (for debugging). */
+        includeSalience?: boolean;
+    };
+    tempoHypotheses?: {
+        /** Minimum BPM to consider. Default: 24. */
+        minBpm?: number;
+        /** Maximum BPM to consider. Default: 300. */
+        maxBpm?: number;
+        /** Histogram bin size in BPM. Default: 1.0. */
+        binSizeBpm?: number;
+        /** Maximum number of hypotheses to return. Default: 10. */
+        maxHypotheses?: number;
+        /** Minimum confidence threshold (0-1). Default: 0.05. */
+        minConfidence?: number;
+        /** Weight IOIs by beat candidate strength. Default: true. */
+        weightByStrength?: boolean;
+        /** Include histogram in output for debugging. Default: false. */
+        includeHistogram?: boolean;
+    };
 };
 
 export type MirAudioPayload = {