moontide-mcp 2.1.0 → 2.4.0

package/dist/protocol.js

@@ -3,6 +3,13 @@
 import { z } from 'zod';
 /** How many of the newest versions the History view loads first. */
 export const HISTORY_WINDOW_SIZE = 100;
+/**
+ * Why the memory guard refused a message: not readable as bytes, longer than it reads, a system exclusive message that
+ * does not end, not a Roland data set for the instrument's model, an instrument whose temporary areas are not known,
+ * an address outside the temporary scene and tones, a wrong checksum, or an NRPN message that is not one of the part offsets of
+ * the NRPN family of the instrument. Worded in src/midi-state.ts.
+ */
+export const MEMORY_GUARD_REASONS = ['not-bytes', 'too-long', 'incomplete', 'not-data-set', 'unknown-areas', 'outside', 'checksum', 'nrpn'];
 // Every string in a midi-state is at most MAX_MIDI_NAME_LENGTH characters (the page cuts longer
 // names with an ellipsis, the server rejects them and never trims); the arrays and the failure
 // name are bounded too.
@@ -16,6 +23,8 @@ export const MAX_MIDI_EVENTS = 20;
 // message. page/midi-rig.js mirrors the limits below (RIG_LIMITS) and the message shape
 // by hand; test/midi-rig.test.js checks both sides.
 export const MAX_RIG_INSTRUMENTS = 16;
+// The most MIDI input ports the setup file may name (its inputs list); mirrored by RIG_LIMITS.inputs in page/midi-rig.js.
+export const MAX_RIG_INPUTS = 4;
 export const MAX_RIG_SOUNDS = 512;
 // The most controls a model may declare: the model schema's own `.max(32)` of `controls` in
 // src/instruments.ts; mirrored by RIG_LIMITS.controls in page/midi-rig.js.
@@ -30,12 +39,24 @@ export const MAX_RIG_PROBLEMS = 20;
 export const MAX_RIG_DRUM_MAPS = 16;
 export const MAX_RIG_DRUM_NOTES = 128;
 export const MAX_RIG_DRUM_NAME = 40;
+// The most setting rows one level (tone, part or scene) of a model may describe, and the most engines a model may
+// declare; mirrored by RIG_LIMITS.settings and RIG_LIMITS.engines in page/midi-rig.js. The page cannot import the
+// vocabulary, so this is a fixed number; test/vocabulary.test.js checks that the whole vocabulary fits in it. It is 512
+// because the MT-32 map holds about 250 tone settings, and a settings event may name every one of them.
+export const MAX_RIG_SETTINGS = 512;
+export const MAX_RIG_ENGINES = 16;
 /**
  * The shortest and longest phrase, in cycles, that set_code accepts with at: 'phrase'. page/change-timing.js
  * mirrors both by hand (test/protocol.test.js checks both sides).
  */
 export const MIN_PHRASE_CYCLES = 2;
 export const MAX_PHRASE_CYCLES = 64;
+/**
+ * The shortest and longest tempo ramp, in whole bars (one bar is one cycle), that set_code and edit_code accept with
+ * glideBars. page/tempo-glide.js mirrors both by hand (test/protocol.test.js checks both sides).
+ */
+export const MIN_GLIDE_BARS = 1;
+export const MAX_GLIDE_BARS = 64;
 /** The largest tempo the page may report in BPM; a bigger number is not music and the schema refuses it. */
 export const MAX_REPORTED_BPM = 100000;
 /** The two scripts the page loads from unpkg.com; a load-failed report names the ones that did not load. */
@@ -73,6 +94,27 @@ export const MAX_REQUEST_LINE_BYTES = 8192;
 export const MOMENT_BEATS = 4;
 // The most characters in a request id (the page makes the id up so answers can be matched).
 export const MAX_ASK_ID_LENGTH = 64;
+// The longest sentence Claude can close a page request with. The page shows it with an ellipsis in a
+// row and whole in the detail.
+export const MAX_ANSWER_TEXT_LENGTH = 200;
+// How the notes of a motif sent from the Scratchpad got on its roll, in the order the request lists them; `mixed` is more than one way.
+// page/scratch-model.js mirrors it by hand (test/ask.test.js checks both sides).
+export const MOTIF_SOURCES = ['played', 'drawn', 'tapped', 'mixed'];
+// The ids of the five grids of the Scratchpad, in the page's order. page/scratch-model.js mirrors them by hand
+// (test/ask.test.js checks both sides).
+export const MOTIF_GRIDS = ['quarter', 'eighth', 'sixteenth', 'eighth-triplet', 'sixteenth-triplet'];
+// The fewest and the most cycles one motif has. page/scratch-model.js mirrors them by hand (test/ask.test.js checks both sides).
+export const MIN_MOTIF_CYCLES = 1;
+export const MAX_MOTIF_CYCLES = 8;
+// The most characters the phrase of a motif has. A bound below MAX_REQUEST_LINE_BYTES so the schema is bounded; the line's own
+// bound stays the real limit, and a phrase is refused whole and never cut. page/ask.js mirrors it by hand (test/ask.test.js checks
+// both sides).
+export const MAX_MOTIF_PHRASE_LENGTH = 8000;
+// The lane of a phrase: note("...").velocity("..."), with only the characters of the phrase inside the quotes.
+const MOTIF_PHRASE_LANE = 'note\\("[a-g0-9#.~_\\[\\],/ <>]*"\\)\\.velocity\\("[a-g0-9#.~_\\[\\],/ <>]*"\\)';
+// The shape of a phrase: one lane, or stack(...) of two or more. Nothing but notes and velocities can travel in the phrase field.
+// page/scratch-model.js's PHRASE_SHAPE is the same pattern, written by hand (test/ask.test.js checks both sides).
+export const MOTIF_PHRASE_SHAPE = new RegExp(`^(${MOTIF_PHRASE_LANE}|stack\\(${MOTIF_PHRASE_LANE}(, ${MOTIF_PHRASE_LANE})+\\))$`);
 // The kinds of thing a right-click can point at. The Jam view is
 // the source of 'note' (a pitch class with its role in the scale) and 'warning' (a chord that leaves it).
 export const ASK_CONTEXT_KINDS = [
@@ -95,6 +137,7 @@ export const ASK_CONTEXT_KINDS = [
     'cell',
     'group',
     'range',
+    'motif',
 ];
 // The kinds of gesture a request can carry: what the user did to a note of the Timeline that the page could not
 // apply itself. page/ask.js mirrors the list by hand (test/ask.test.js checks both sides).
@@ -104,6 +147,12 @@ export const MAX_GESTURE_SEMITONES = 127;
 const audioStateSchema = z.enum(['playing', 'waiting-for-click', 'stopped']);
 const midiName = z.string().max(MAX_MIDI_NAME_LENGTH);
 const midiChannel = z.number().int().min(1).max(16);
+// The names of the settings an event is about: a setting name is a lowercase letter, then letters and digits
+// (page/midi-rig.js reads the same pattern), and a level holds at most MAX_RIG_SETTINGS of them.
+const settingNames = z
+    .array(z.string().regex(/^[a-z][A-Za-z0-9]{0,39}$/))
+    .min(1)
+    .max(MAX_RIG_SETTINGS);
 // A longer string is rejected, never trimmed (the page cuts before it sends).
 const askString = z.string().max(MAX_ASK_CONTEXT_LENGTH);
 const askName = askString.min(1);
@@ -159,6 +208,18 @@ export const askGestureSchema = z.discriminatedUnion('kind', [
         more: z.number().int().nonnegative(),
     }),
 ]);
+// The keys of a motif. z.object drops a key it does not name, so test/ask.test.js pins these keys equal to the ones page/scratch-model.js's
+// motifRequest can give. A cycle, a count or a phrase out of bounds is rejected, never trimmed, and a phrase that is not in the phrase form
+// is rejected whole.
+export const askMotifShape = {
+    source: z.enum(MOTIF_SOURCES),
+    cycle: z.number().int().nonnegative().optional(),
+    cycles: z.number().int().min(MIN_MOTIF_CYCLES).max(MAX_MOTIF_CYCLES),
+    grid: z.enum(MOTIF_GRIDS),
+    notes: z.number().int().min(1),
+    phrase: z.string().min(1).max(MAX_MOTIF_PHRASE_LENGTH).regex(MOTIF_PHRASE_SHAPE),
+};
+const askMotifSchema = z.object(askMotifShape);
 const askContextSchema = z.discriminatedUnion('kind', [
     z.object({ kind: z.literal('session') }),
     z.object({ kind: z.literal('version'), id: z.number().int().positive(), label: askName.optional() }),
@@ -195,11 +256,14 @@ const askContextSchema = z.discriminatedUnion('kind', [
         track: askName,
         from: z.number().int().nonnegative(),
         to: z.number().int().nonnegative(),
-        section: askName.optional(),
-        sectionTo: askName.optional(),
+        sections: z.array(askName).min(1).max(MAX_RANGE_CYCLES).optional(),
+        moreSections: z.number().int().min(1).max(MAX_RANGE_CYCLES - 1).optional(),
     })
         .refine((range) => range.to >= range.from && range.to - range.from < MAX_RANGE_CYCLES, {
         message: `a range covers 1 to ${MAX_RANGE_CYCLES} whole cycles, to not before from`,
+    })
+        .refine((range) => range.moreSections === undefined || range.sections !== undefined, {
+        message: 'moreSections comes only with sections',
     }),
     // `note` is a pitch class name, never an octave, string or fret; `role` and `scale` are both present or
     // both absent (the page enforces that), absent while the scale is not clear.
@@ -234,6 +298,7 @@ const askContextSchema = z.discriminatedUnion('kind', [
         message: 'outside notes come only with a fit of does-not-fit',
     }),
     z.object({ kind: z.literal('group'), name: askName, parent: askName.optional() }),
+    z.object({ kind: z.literal('motif') }),
 ]);
 /** A structure note holds at most this many lines, each at most this many characters. */
 export const MAX_STRUCTURE_NOTE_LINES = 3;
@@ -244,6 +309,26 @@ const pendingChangeSchema = z.object({
     cycle: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
     seconds: z.number().finite().nonnegative().max(MAX_PENDING_SECONDS),
 });
+const glideBpmSchema = z.number().finite().positive().max(MAX_REPORTED_BPM);
+// A discriminated union on `state` so a later state is one more member.
+const glideReportSchema = z.discriminatedUnion('state', [
+    z.object({
+        state: z.literal('started'),
+        fromBpm: glideBpmSchema,
+        toBpm: glideBpmSchema,
+        bars: z.number().int().min(MIN_GLIDE_BARS).max(MAX_GLIDE_BARS),
+    }),
+    z.object({
+        state: z.literal('at-line'),
+        toBpm: glideBpmSchema,
+        bars: z.number().int().min(MIN_GLIDE_BARS).max(MAX_GLIDE_BARS),
+    }),
+    z.object({
+        state: z.literal('running'),
+        nowBpm: glideBpmSchema,
+        toBpm: glideBpmSchema,
+    }),
+]);
 // A plain z.union (not discriminatedUnion): 'runtime-error' has no 'ok' field, so the
 // single-key discriminant used for the two 'evaluated' variants can't cover it.
 const pageMessageSchema = z.union([
@@ -255,10 +340,12 @@ const pageMessageSchema = z.union([
         audio: audioStateSchema,
         pending: pendingChangeSchema.optional(),
         bpm: z.number().finite().positive().max(MAX_REPORTED_BPM).optional(),
+        glide: glideReportSchema.optional(),
     }),
     z.object({
         type: z.literal('takeover'),
         id: z.string().min(1).max(64),
+        glideRuns: z.literal(true).optional(),
     }),
     z.object({
         type: z.literal('takeover-canceled'),
@@ -272,6 +359,12 @@ const pageMessageSchema = z.union([
         code: z.string(),
         error: z.string(),
         line: z.number().int().positive().optional(),
+        glideRefused: z.literal(true).optional(),
+    }),
+    z.object({
+        type: z.literal('glide-ended'),
+        reason: z.enum(['finished', 'other-tempo', 'no-tempo', 'error']),
+        bpm: glideBpmSchema.optional(),
     }),
     z.object({
         type: z.literal('runtime-error'),
@@ -318,6 +411,7 @@ const pageMessageSchema = z.union([
         label: z.string().min(1).max(MAX_MIXER_LABEL_LENGTH),
     }),
     z.object({ type: z.literal('history-request') }),
+    z.object({ type: z.literal('ask-board-request') }),
     z.object({ type: z.literal('data-folder-request') }),
     z.object({ type: z.literal('take-over') }),
     z.object({ type: z.literal('history-restore'), id: z.number().int().positive() }),
@@ -341,9 +435,10 @@ const pageMessageSchema = z.union([
         context: askContextSchema,
         chip: z.string().min(1).max(MAX_ASK_CONTEXT_LENGTH),
         current: z.number().int().positive().nullable(),
-        // z.object drops a key it does not name, so the moment and the gesture must be named here to reach Claude.
+        // z.object drops a key it does not name, so the moment, the gesture and the motif must be named here to reach Claude.
         moment: askMomentSchema.optional(),
         gesture: askGestureSchema.optional(),
+        motif: askMotifSchema.optional(),
     })
         // A gesture about one note of a lane rides only on a lane context that carries a moment; the range gesture and the range
         // context come together and carry no moment (the notes of the range are in the gesture).
@@ -352,7 +447,11 @@ const pageMessageSchema = z.union([
         if (isRange || ask.context.kind === 'range')
             return isRange && ask.context.kind === 'range' && ask.moment === undefined;
         return ask.gesture === undefined || (ask.context.kind === 'lane' && ask.moment !== undefined);
-    }, { message: 'a gesture needs a lane context and a moment, and a range gesture goes only with a range context' }),
+    }, { message: 'a gesture needs a lane context and a moment, and a range gesture goes only with a range context' })
+        // A motif goes only with the motif context and the motif context needs one; a motif request carries no moment and no gesture.
+        .refine((ask) => (ask.motif !== undefined) === (ask.context.kind === 'motif') && (ask.motif === undefined || (ask.moment === undefined && ask.gesture === undefined)), {
+        message: 'a motif goes only with a motif context, which needs it, and carries no moment and no gesture',
+    }),
     z.object({
         type: z.literal('midi-state'),
         access: z.enum(['idle', 'pending', 'enabled', 'denied', 'unsupported', 'failed']),
@@ -380,9 +479,28 @@ const pageMessageSchema = z.union([
             z.object({
                 kind: z.literal('send-failed'),
                 instrument: midiName,
-                what: z.enum(['reset', 'setup']),
+                what: z.enum(['reset', 'setup', 'settings']),
                 failure: z.string().max(MAX_MIDI_FAILURE_LENGTH),
             }),
+            z.object({ kind: z.literal('settings-scene'), instrument: midiName, names: settingNames }),
+            z
+                .object({
+                kind: z.literal('settings-left'),
+                instrument: midiName,
+                level: z.enum(['tone', 'part', 'scene']),
+                channel: midiChannel.nullable(),
+                names: settingNames,
+            })
+                // A tone or part setting belongs to a channel; a scene setting reaches every part and has none.
+                .refine((event) => (event.level === 'scene') === (event.channel === null), {
+                message: 'a scene setting has no channel, a tone or part setting has one',
+            }),
+            z.object({
+                kind: z.literal('sysex-refused'),
+                instrument: midiName,
+                source: z.enum(['code', 'settings', 'reset']),
+                reason: z.enum(MEMORY_GUARD_REASONS),
+            }),
             z.object({ kind: z.literal('clock-dropped') }),
         ]))
             .max(MAX_MIDI_EVENTS)

package/dist/reference.js

@@ -65,6 +65,18 @@ export const REFERENCE_TOPICS = [
         title: 'MIDI output',
         summary: 'sending a track to a MIDI port with .midi(): port names, channels, notes, control and program changes, the MIDI clock Moontide sends, and what Stop sends',
     },
+    {
+        id: 'settings',
+        file: 'settings.md',
+        title: 'Synth settings',
+        summary: 'the tone, part and scene settings of a MIDI instrument written in .midi(): what each level reaches, the setting names, what is refused, when they are sent and what undoes them',
+    },
+    {
+        id: 'motif',
+        file: 'motif.md',
+        title: 'Motif requests',
+        summary: 'how to read a motif sent from the Scratchpad: its fields, the moment, the grid, the phrase form, the velocities, the source words, what the words can ask and what the page did',
+    },
 ];
 export const REFERENCE_TOPIC_IDS = REFERENCE_TOPICS.map((topic) => topic.id);
 /** Module-relative, not cwd-relative (works wherever npm installs the package). */

package/dist/request-status.js

@@ -0,0 +1,221 @@
+// The request status board: what became of each request a page sent to Claude.
+//
+// The board holds one row per request the page sent, keyed by the id the page made up: the page that
+// sent it, its state and the start of the text and the chip, kept in memory only so a reloaded page can
+// show what it asked. Nothing is ever written to disk and the board holds at most MAX_BOARD_REQUESTS
+// rows (the oldest finished row goes first, an open one only when every row is open). A state only
+// moves forward: a repeat, a step back and any change after a final state are ignored, so the page is
+// never told the same thing twice and never told something that undoes what it was told. A state
+// reaches only the page that sent the request; once that page has gone the row keeps its state and
+// nothing is sent.
+//
+// The page already learns "sent", "waiting" and "received" from the ask-result and ask-received
+// messages. The board adds the states that come later and sends them as ask-status.
+import { MAX_ASK_CONTEXT_LENGTH } from './protocol.js';
+/** How many requests the board keeps; the oldest finished row is dropped first. */
+export const MAX_BOARD_REQUESTS = 50;
+// In the order a request moves through them. page/request-status.js mirrors this list by hand.
+export const REQUEST_STATES = [
+    'sent',
+    'waiting',
+    'received',
+    'started',
+    'line',
+    'applied',
+    'failed',
+    'replaced',
+    'canceled',
+    'answered',
+    'declined',
+];
+/** A request in one of these is finished: nothing follows it. */
+export const FINAL_REQUEST_STATES = [
+    'applied',
+    'failed',
+    'replaced',
+    'canceled',
+    'answered',
+    'declined',
+];
+/** Said when a request is closed by its id and the id is not an open request. */
+export const NOT_OPEN_REQUEST_MESSAGE = 'No open page request has this id: it is unknown or already closed. Nothing changed in the page.';
+// Whitespace, C0 and C1 control characters, the line and paragraph separators and the bidirectional
+// override and isolate characters: none of them belongs in a sentence the page shows to the user.
+const ANSWER_NOISE = /[\s\u0000-\u001F\u007F-\u009F\u2028\u2029\u202A-\u202E\u2066-\u2069]+/gu;
+/** The sentence Claude closes a request with, as the page shows it: each run of noise becomes one space. */
+export function cleanAnswerText(text) {
+    return text.replace(ANSWER_NOISE, ' ').trim();
+}
+/** Where a state stands in the order: 0 to 4 for sent to line, 5 for every final state. */
+export function requestRank(state) {
+    if (FINAL_REQUEST_STATES.includes(state)) {
+        return 5;
+    }
+    return REQUEST_STATES.indexOf(state);
+}
+/** The start of a request text: at most MAX_ASK_CONTEXT_LENGTH code points, an ellipsis when it was cut. */
+function textStart(text) {
+    const points = Array.from(text);
+    return points.length <= MAX_ASK_CONTEXT_LENGTH ? text : `${points.slice(0, MAX_ASK_CONTEXT_LENGTH).join('')}\u2026`;
+}
+export class RequestStatusBoard {
+    send;
+    max;
+    now;
+    // Insertion order is arrival order, so the first key is the oldest request.
+    rows = new Map();
+    constructor(options) {
+        this.send = options.send;
+        this.max = options.max ?? MAX_BOARD_REQUESTS;
+        this.now = options.now ?? Date.now;
+    }
+    /** A request was accepted: it is sent to a listener, or queued until a tool reply. */
+    opened(id, origin, options) {
+        // The channel refuses an id the board holds before it gets here, so a row is never silently reset.
+        if (this.rows.has(id)) {
+            throw new Error(`The request id ${JSON.stringify(id)} is already on the request board`);
+        }
+        const at = this.now();
+        this.rows.set(id, {
+            origin,
+            state: options.queued ? 'waiting' : 'sent',
+            text: textStart(options.text),
+            chip: options.chip,
+            openedAt: at,
+            newsAt: at,
+            last: undefined,
+        });
+        // The bound caps memory, not live work: the oldest finished row goes first. Only when every row is
+        // still open does the oldest open row go.
+        while (this.rows.size > this.max) {
+            let victim;
+            for (const [rowId, row] of this.rows) {
+                if (FINAL_REQUEST_STATES.includes(row.state)) {
+                    victim = rowId;
+                    break;
+                }
+            }
+            victim ??= this.rows.keys().next().value;
+            if (victim === undefined)
+                break;
+            this.rows.delete(victim);
+        }
+    }
+    /** A request that was sent to a listener went back to the queue. */
+    waiting(id) {
+        this.advance(id, 'waiting');
+    }
+    /** Requests were handed to Claude, by a listener or in a tool reply. */
+    delivered(ids) {
+        for (const id of ids) {
+            this.advance(id, 'received');
+        }
+    }
+    /**
+     * A Moontide tool call began. Every request already handed to Claude is now being worked on: Claude
+     * made a call after the request arrived. A request handed over by this very call is still waiting to
+     * be marked, because the mark comes before the reply hands it over.
+     */
+    noteToolCall() {
+        for (const [id, row] of this.rows) {
+            if (row.state === 'received') {
+                this.advance(id, 'started', { type: 'ask-status', id, state: 'started' });
+            }
+        }
+    }
+    /** On the board, open or finished. */
+    has(id) {
+        return this.rows.has(id);
+    }
+    /** On the board and not finished. */
+    isOpen(id) {
+        const row = this.rows.get(id);
+        return row !== undefined && !FINAL_REQUEST_STATES.includes(row.state);
+    }
+    /** The change that answers this request is playing, as the history version it was recorded as. */
+    applied(id, version) {
+        this.advance(id, 'applied', { type: 'ask-status', id, state: 'applied', version });
+    }
+    /** A change that answers this request waits for its bar or phrase line. */
+    line(id, at) {
+        this.advance(id, 'line', { type: 'ask-status', id, state: 'line', at });
+    }
+    /** The change that answers this request could not be evaluated; the reason is already cleaned. */
+    failed(id, reason) {
+        this.advance(id, 'failed', { type: 'ask-status', id, state: 'failed', reason });
+    }
+    /** A newer change took the place of the waiting one that answered this request. */
+    replaced(id) {
+        this.advance(id, 'replaced', { type: 'ask-status', id, state: 'replaced' });
+    }
+    /** Stop, or the page leaving, ended the wait of the change that answered this request. */
+    canceled(id) {
+        this.advance(id, 'canceled', { type: 'ask-status', id, state: 'canceled' });
+    }
+    /**
+     * Claude closed this request in words, without a change to the music. Returns false when the id is not
+     * an open request, so the caller can refuse it loudly.
+     */
+    closed(id, outcome, answer) {
+        if (!this.isOpen(id)) {
+            return false;
+        }
+        this.advance(id, outcome, { type: 'ask-status', id, state: outcome, answer });
+        return true;
+    }
+    /**
+     * What a page that asks for the board is told: the requests whose page has gone and the ones it sent
+     * itself, oldest first. The gone ones now belong to it, so their next states reach it. A request of
+     * another page that is still connected is never listed.
+     */
+    snapshotFor(conn) {
+        const at = this.now();
+        const entries = [];
+        for (const [id, row] of this.rows) {
+            if (row.origin !== null && row.origin !== conn) {
+                continue;
+            }
+            row.origin = conn;
+            const entry = {
+                id,
+                text: row.text,
+                chip: row.chip,
+                state: row.state,
+                openedAgoMs: at - row.openedAt,
+                newsAgoMs: at - row.newsAt,
+            };
+            const last = row.last;
+            if (last?.state === 'applied')
+                entry.version = last.version;
+            if (last?.state === 'line')
+                entry.at = last.at;
+            if (last?.state === 'failed')
+                entry.reason = last.reason;
+            if (last?.state === 'answered' || last?.state === 'declined')
+                entry.answer = last.answer;
+            entries.push(entry);
+        }
+        return entries;
+    }
+    /** The page that sent these requests has gone: the rows keep their state and nothing more is sent. */
+    pageGone(conn) {
+        for (const row of this.rows.values()) {
+            if (row.origin === conn) {
+                row.origin = null;
+            }
+        }
+    }
+    // The one place a state changes. It does nothing for an unknown id or a state that is not higher.
+    advance(id, state, message) {
+        const row = this.rows.get(id);
+        if (row === undefined || requestRank(state) <= requestRank(row.state)) {
+            return;
+        }
+        row.state = state;
+        row.newsAt = this.now();
+        row.last = message;
+        if (message !== undefined && row.origin !== null) {
+            this.send(row.origin, message, 'the request status');
+        }
+    }
+}