@maestrofrontier/frontier 1.4.0

package/frontier/dispatch.cjs

@@ -0,0 +1,255 @@
+#!/usr/bin/env node
+// Maestro Frontier — CLI-spawn + parallel-fanout for panel adapters.
+// spawnOne: one adapter invocation -> PanelResponse (never rejects).
+// fanOut:   bounded-concurrent map over modelIds -> PanelResponse[].
+
+'use strict';
+
+const { spawn } = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const { stripLlmWrapper } = require('./schema.cjs');
+const { mapLimit } = require('./semaphore.cjs');
+
+const MAX_BUF = 2 * 1024 * 1024; // 2 MB cap per stream
+
+/** @param {string} p @returns {string} */
+function safeReadFile(p) {
+  try { return fs.readFileSync(p, 'utf8'); } catch { return ''; }
+}
+
+// Residual cmd.exe hazards for a prompt passed as an ARGUMENT on win32.
+// Win32 npm shims (codex/gemini, extensionless) cannot be spawned with
+// shell:false (Node v18.20+/20.12+/24 throw EINVAL on .cmd/.bat), and
+// shell:true concatenates args unescaped (DEP0190). So we wrap them in an
+// explicit `cmd.exe /d /s /c <shim> ...` with shell:false: Node then applies
+// its standard argv quoting to every element, so spaces and &|<>() inside the
+// quoted prompt are literal to cmd and there is no unescaped concat. What
+// Node's C-runtime quoting does NOT reconcile with cmd.exe is the double quote
+// and percent (cmd still expands %VAR% on the /c line). stdin adapters
+// (claude, codex) are unaffected; only the promptVia:'arg' shim path (gemini)
+// is, so we refuse a prompt bearing those residual chars there. Plain prose —
+// spaces and most punctuation included — passes.
+const CMD_UNSAFE_RE = new RegExp('["%\\r\\n]');
+function unsafeForShellArg(s) {
+  return CMD_UNSAFE_RE.test(String(s));
+}
+
+/**
+ * Spawn one adapter process and return a PanelResponse (never rejects).
+ * @param {string} prompt
+ * @param {object} adapter  — DEFAULTS.adapters[id] shape
+ * @param {{ timeoutMs?: number, fusionDepth?: number }} [opts]
+ * @returns {Promise<import('./schema.cjs').PanelResponse>}
+ */
+function spawnOne(prompt, adapter, opts) {
+  const timeoutMs   = (opts && opts.timeoutMs  != null) ? opts.timeoutMs  : 180000;
+  const fusionDepth = (opts && opts.fusionDepth != null) ? opts.fusionDepth : 1;
+
+  return new Promise((resolve) => {
+    const start = Date.now();
+
+    // Guard: missing/invalid adapter
+    if (!adapter || typeof adapter !== 'object') {
+      return resolve({
+        model: '', content: '', ok: false, durationMs: 0, tokensEst: 0,
+        error: 'spawn error: adapter is undefined',
+      });
+    }
+
+    // ---- build invocation ----
+    // Node scripts (test stubs) run via process.execPath; win32 npm shims go
+    // through an explicit cmd.exe wrapper (see CMD_UNSAFE_RE note); everything
+    // else (claude.exe, POSIX bins) spawns directly. shell is always false.
+    const isNodeScript = /\.[cm]?js$/i.test(adapter.bin);
+    const isWinShim    = !isNodeScript && process.platform === 'win32' && !path.extname(adapter.bin);
+
+    // program args: base flags (+ optional output file) (+ optional prompt arg)
+    const progArgs = [...(adapter.baseArgs || [])];
+
+    // last-message-file: unique tmp path
+    let tmpPath = null;
+    if (adapter.output === 'last-message-file') {
+      tmpPath = path.join(
+        os.tmpdir(),
+        'frontier-' + process.pid + '-' + Date.now() + '-' +
+          Math.random().toString(36).slice(2) + '.txt'
+      );
+      progArgs.push('--output-last-message', tmpPath);
+    }
+
+    // prompt delivery via arg (stdin path is written after spawn)
+    if (adapter.promptVia === 'arg') {
+      if (isWinShim && unsafeForShellArg(prompt)) {
+        return resolve({
+          model: adapter.model, content: '', ok: false,
+          durationMs: Date.now() - start, tokensEst: 0,
+          error: 'unsafe prompt for win32 arg-path adapter (contains a quote, ' +
+            'percent, or newline); use a stdin-capable model or remove those characters',
+        });
+      }
+      progArgs.push(adapter.promptFlag || '-p', prompt);
+    }
+
+    let bin, spawnArgs;
+    if (isNodeScript) {
+      bin = process.execPath;
+      spawnArgs = [adapter.bin, ...progArgs];
+    } else if (isWinShim) {
+      bin = process.env.ComSpec || 'cmd.exe';
+      spawnArgs = ['/d', '/s', '/c', adapter.bin, ...progArgs];
+    } else {
+      bin = adapter.bin;
+      spawnArgs = progArgs;
+    }
+
+    const env = { ...process.env, FUSION_DEPTH: String(fusionDepth), ...(adapter.env || {}) };
+
+    let child;
+    try {
+      child = spawn(bin, spawnArgs, { shell: false, env, windowsHide: true });
+    } catch (spawnErr) {
+      return resolve({
+        model: adapter.model, content: '', ok: false,
+        durationMs: Date.now() - start, tokensEst: 0,
+        error: 'spawn error: ' + spawnErr.message,
+      });
+    }
+
+    // stdin delivery
+    if (adapter.promptVia !== 'arg') {
+      child.stdin.on('error', () => {});
+      try { child.stdin.write(prompt); child.stdin.end(); } catch {}
+    }
+
+    let stdoutBuf = '';
+    let stderrBuf = '';
+
+    child.stdout.setEncoding('utf8');
+    child.stdout.on('data', (chunk) => {
+      stdoutBuf += chunk;
+      if (stdoutBuf.length > MAX_BUF) stdoutBuf = stdoutBuf.slice(-MAX_BUF);
+    });
+
+    child.stderr.setEncoding('utf8');
+    child.stderr.on('data', (chunk) => {
+      stderrBuf += chunk;
+      if (stderrBuf.length > MAX_BUF) stderrBuf = stderrBuf.slice(-MAX_BUF);
+    });
+
+    // timeout
+    let timedOut  = false;
+    let killTimer = null;
+    const timer = setTimeout(() => {
+      timedOut  = true;
+      child.kill('SIGTERM');
+      killTimer = setTimeout(() => child.kill('SIGKILL'), 2000);
+    }, timeoutMs);
+
+    child.on('error', (err) => {
+      clearTimeout(timer);
+      if (killTimer) clearTimeout(killTimer);
+      resolve({
+        model: adapter.model, content: '', ok: false,
+        durationMs: Date.now() - start, tokensEst: 0,
+        error: 'spawn error: ' + err.message,
+      });
+    });
+
+    child.on('close', (code, signal) => {
+      clearTimeout(timer);
+      if (killTimer) clearTimeout(killTimer);
+
+      // ---- parse stdout -> content (read tmp file BEFORE cleanup) ----
+      let content    = '';
+      let parseError = null;
+
+      if (adapter.parse === 'claude-json') {
+        let parsed;
+        try { parsed = JSON.parse(stdoutBuf); } catch {
+          parseError = 'claude json parse fail';
+        }
+        if (!parseError) {
+          if (parsed && parsed.is_error) {
+            parseError = String(parsed.result || 'is_error');
+          } else {
+            content = stripLlmWrapper(String((parsed && parsed.result) || '').trim());
+          }
+        }
+      } else if (adapter.parse === 'gemini-json') {
+        let parsed;
+        try { parsed = JSON.parse(stdoutBuf); } catch {
+          parseError = 'gemini json parse fail';
+        }
+        if (!parseError) {
+          content = stripLlmWrapper(String((parsed && parsed.response) || '').trim());
+        }
+      } else {
+        // 'text': prefer last-message-file content, fall back to stdout
+        const raw = (adapter.output === 'last-message-file' ? safeReadFile(tmpPath) : '') || stdoutBuf;
+        content = stripLlmWrapper(String(raw).trim());
+      }
+
+      // tmp-file cleanup (after read)
+      if (tmpPath) {
+        try { fs.unlinkSync(tmpPath); } catch {}
+      }
+
+      const ok = (code === 0) && !timedOut && content.length > 0 && !parseError;
+      let error;
+      if (!ok) {
+        error = parseError ||
+          (timedOut
+            ? 'timeout'
+            : ('exit ' + code + (signal ? (' ' + signal) : '') +
+               (stderrBuf ? ': ' + stderrBuf.slice(0, 500) : '')));
+      }
+
+      const durationMs = Date.now() - start;
+      const tokensEst  = Math.ceil(content.length / 4);
+      resolve({
+        model: adapter.model, content, ok, durationMs, tokensEst,
+        ...(ok ? {} : { error }),
+      });
+    });
+  });
+}
+
+/**
+ * fanOut — run spawnOne over modelIds bounded by concurrency; order preserved.
+ * @param {string} prompt
+ * @param {string[]} modelIds
+ * @param {{ adapters: object, timeoutMs: number, concurrency: number }} cfg
+ * @param {{ fusionDepth?: number, concurrency?: number }} [opts]
+ * @returns {Promise<import('./schema.cjs').PanelResponse[]>}
+ */
+async function fanOut(prompt, modelIds, cfg, opts) {
+  const fusionDepth = (opts && opts.fusionDepth != null) ? opts.fusionDepth : 1;
+  const concurrency = (opts && opts.concurrency != null)
+    ? opts.concurrency
+    : Math.min(modelIds.length, (cfg && cfg.concurrency) || 4);
+
+  const settled = await mapLimit(modelIds, concurrency, (id) => {
+    const adapter = cfg && cfg.adapters && cfg.adapters[id];
+    // undefined adapter -> spawnOne resolves a failed PanelResponse
+    return spawnOne(prompt, adapter, {
+      timeoutMs: (cfg && cfg.timeoutMs) || 180000,
+      fusionDepth,
+    });
+  });
+
+  return settled.map((s, i) => {
+    if (s.ok) return s.value;
+    // spawnOne never rejects, but be defensive
+    const adapter = cfg && cfg.adapters && cfg.adapters[modelIds[i]];
+    return {
+      model: adapter ? adapter.model : modelIds[i],
+      content: '', ok: false, durationMs: 0, tokensEst: 0,
+      error: String(s.error),
+    };
+  });
+}
+
+module.exports = { spawnOne, fanOut, unsafeForShellArg };

package/frontier/judge.cjs

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+// Maestro Frontier — judge stage: build prompt + invoke Opus to produce Analysis.
+
+'use strict';
+
+const { parseAnalysis } = require('./schema.cjs');
+const dispatch = require('./dispatch.cjs');
+
+/**
+ * Build the judge prompt for Opus.
+ * @param {string} userPrompt
+ * @param {import('./schema.cjs').PanelResponse[]} responses
+ * @param {object} cfg
+ * @returns {string}
+ */
+function buildJudgePrompt(userPrompt, responses, cfg) {
+  const sections = responses.map(
+    r => `### Response from ${r.model}\n${r.content}`
+  ).join('\n\n');
+
+  const domainNote = (cfg.excluded_domains && cfg.excluded_domains.length > 0)
+    ? `\nDisregard any claims sourced only from the following domains: ${cfg.excluded_domains.join(', ')}.\n`
+    : '';
+
+  return `You are a neutral JUDGE evaluating multiple AI panel responses to a user question.
+
+USER QUESTION:
+${userPrompt}
+
+PANEL RESPONSES:
+${sections}
+${domainNote}
+INSTRUCTIONS:
+COMPARE the panel responses — do NOT merge or summarize them. Perform a structured analysis:
+- consensus: points that all or most models agree on
+- contradictions: topics where models disagree, with each model's specific stance
+- partial_coverage: points that only some models covered (with which models)
+- unique_insights: insights raised by exactly one model (with which model)
+- blind_spots: important points that NO model addressed
+
+OUTPUT IS ONLY a single JSON object with EXACTLY these keys:
+  consensus (string[])
+  contradictions (array of {topic: string, stances: [{model: string, stance: string}]})
+  partial_coverage (array of {models: string[], point: string})
+  unique_insights (array of {model: string, insight: string})
+  blind_spots (string[])
+
+No prose before or after. No markdown fence. No extra keys. Output the raw JSON object only.`;
+}
+
+/**
+ * Run the judge stage. Returns Analysis or undefined on any failure (degrades gracefully).
+ * @param {string} userPrompt
+ * @param {import('./schema.cjs').PanelResponse[]} responses
+ * @param {object} cfg
+ * @param {{ spawn?: Function }} [deps]
+ * @returns {Promise<import('./schema.cjs').Analysis | undefined>}
+ */
+async function runJudge(userPrompt, responses, cfg, deps) {
+  const spawn = (deps && deps.spawn) || dispatch.spawnOne;
+  let r;
+  try {
+    r = await spawn(
+      buildJudgePrompt(userPrompt, responses, cfg),
+      cfg.adapters[cfg.judgeModel],
+      { timeoutMs: cfg.timeoutMs, fusionDepth: 1 }
+    );
+  } catch {
+    return undefined;
+  }
+
+  if (!r || !r.ok || !r.content) return undefined;
+
+  // Primary parse
+  try {
+    return parseAnalysis(r.content);
+  } catch {
+    // substring recovery: find outermost { ... }
+    const first = r.content.indexOf('{');
+    const last  = r.content.lastIndexOf('}');
+    if (first !== -1 && last > first) {
+      try {
+        return parseAnalysis(r.content.slice(first, last + 1));
+      } catch {
+        return undefined;
+      }
+    }
+    return undefined;
+  }
+}
+
+module.exports = { buildJudgePrompt, runJudge };

package/frontier/run.cjs

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+// Maestro Frontier — mode router (off / single / fusion).
+// runFrontier({prompt, state, cfg, deps}) -> Promise<FusionResult>.
+//
+// Re-grounding note (Fable T2): the engine fans a prompt to model CLIs
+// that do NOT share this session's file/context. A member or synthesis
+// output asserting "I can't see X" / "no such file" reflects that
+// subprocess's blank context, not ground truth — re-ground such claims
+// against live context before relaying them to the user (AGENTS.md S7.7).
+
+'use strict';
+
+const { DEFAULTS } = require('./config.cjs');
+const { resolvePanel, resolveJudgeModel, resolveSynthModel } = require('./config.cjs');
+const { classify, toFailedModel } = require('./schema.cjs');
+const dispatch = require('./dispatch.cjs');
+const judge = require('./judge.cjs');
+const synthesize = require('./synthesize.cjs');
+
+/**
+ * @param {{ prompt:string, state:object, cfg?:object, deps?:object }} opts
+ * @returns {Promise<object>}
+ */
+async function runFrontier({ prompt, state, cfg, deps }) {
+  cfg = cfg || DEFAULTS;
+  deps = deps || {};
+
+  const spawnOne  = deps.spawnOne  || dispatch.spawnOne;
+  const fanOut    = deps.fanOut    || dispatch.fanOut;
+  const runJudge  = deps.runJudge  || judge.runJudge;
+  const runSynth  = deps.runSynth  || synthesize.runSynth;
+
+  const rawDepth = parseInt(process.env.FUSION_DEPTH || '0', 10);
+  const depth    = isNaN(rawDepth) ? 0 : rawDepth;
+
+  // ---- OFF ----
+  if (state.mode === 'off') {
+    return { status: 'off', mode: 'off', final: null };
+  }
+
+  // ---- RECURSION GUARD (single + fusion) ----
+  if (depth >= 1) {
+    const base = {
+      status: 'error',
+      mode: state.mode,
+      error: 'fusion depth exceeded (one-level cap)',
+      failure_reason: 'fusion_invocation_capped',
+    };
+    if (state.mode === 'fusion') return { ...base, preset: state.preset };
+    if (state.mode === 'single') return { ...base, model: state.model };
+    return base;
+  }
+
+  // ---- SINGLE ----
+  if (state.mode === 'single') {
+    const adapter = cfg.adapters && cfg.adapters[state.model];
+    if (!adapter) {
+      return {
+        status: 'error',
+        mode: 'single',
+        model: state.model,
+        error: 'unknown model: ' + state.model,
+        failure_reason: 'unexpected_error',
+      };
+    }
+    const resp = await spawnOne(prompt, adapter, { timeoutMs: cfg.timeoutMs, fusionDepth: depth + 1 });
+    if (!resp.ok) {
+      return {
+        status: 'error',
+        mode: 'single',
+        model: state.model,
+        error: resp.error,
+        failure_reason: classify([toFailedModel(resp)]),
+      };
+    }
+    return { status: 'ok', mode: 'single', model: state.model, final: resp.content, response: resp };
+  }
+
+  // ---- FUSION ----
+  if (state.mode === 'fusion') {
+    // resolve panel
+    let panelIds;
+    try {
+      panelIds = resolvePanel(state, cfg);
+    } catch (e) {
+      return {
+        status: 'error',
+        mode: 'fusion',
+        preset: state.preset,
+        error: e.message,
+        failure_reason: 'unexpected_error',
+      };
+    }
+
+    // BUDGET (opt-in)
+    if (cfg.tokenBudget && cfg.tokenBudget > 0) {
+      const projected = Math.ceil(prompt.length / 4) * panelIds.length;
+      if (projected > cfg.tokenBudget) {
+        return {
+          status: 'error',
+          mode: 'fusion',
+          preset: state.preset,
+          error: 'projected token budget exceeded (' + projected + '>' + cfg.tokenBudget + ')',
+          failure_reason: 'unexpected_error',
+        };
+      }
+    }
+
+    const panel  = await fanOut(prompt, panelIds, cfg, { fusionDepth: depth + 1 });
+    const ok     = panel.filter(p => p.ok);
+    const failed = panel.filter(p => !p.ok);
+
+    if (ok.length === 0) {
+      return {
+        status: 'error',
+        mode: 'fusion',
+        preset: state.preset,
+        error: 'all panels failed',
+        failure_reason: classify(failed.map(toFailedModel)),
+      };
+    }
+
+    // Resolve judge/synth model (explicit flag -> preset override -> default)
+    // and hand the judge/synth stages a cfg pinned to those models, so a
+    // preset like gpt-duo runs entirely on its own provider.
+    const stageCfg = {
+      ...cfg,
+      judgeModel: resolveJudgeModel(state, cfg),
+      synthModel: resolveSynthModel(state, cfg),
+    };
+    const analysis = await runJudge(prompt, ok, stageCfg);
+    let final = await runSynth(prompt, { analysis, responses: ok }, stageCfg);
+    if (!final) {
+      // synth-fail fallback: longest ok response
+      final = ok.reduce((a, b) => b.content.length > a.content.length ? b : a).content;
+    }
+
+    const result = { status: 'ok', mode: 'fusion', preset: state.preset, final, responses: ok };
+    if (analysis !== undefined) result.analysis = analysis;
+    if (failed.length) result.failed_models = failed.map(toFailedModel);
+    return result;
+  }
+
+  // ---- UNKNOWN MODE ----
+  return { status: 'error', mode: state.mode, error: 'unknown mode', failure_reason: 'unexpected_error' };
+}
+
+module.exports = { runFrontier };

package/frontier/schema.cjs

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+// Maestro Frontier — shared types-as-validators + helpers.
+// Zero deps, CJS. Ported stripLlmWrapper from scripts/compress.cjs.
+
+'use strict';
+
+/**
+ * @typedef {{ model:string, content:string, ok:boolean, durationMs:number, tokensEst:number, toolCalls?:unknown[], error?:string }} PanelResponse
+ * @typedef {{ model:string, reason:string }} FailedModel
+ * @typedef {{ consensus:string[], contradictions:{topic:string,stances:{model:string,stance:string}[]}[], partial_coverage:{models:string[],point:string}[], unique_insights:{model:string,insight:string}[], blind_spots:string[] }} Analysis
+ */
+
+/** @type {string[]} */
+const FAILURE_REASONS = [
+  'all_panels_failed',
+  'insufficient_credits',
+  'rate_limited',
+  'fusion_invocation_capped',
+  'unexpected_error',
+];
+
+/**
+ * @param {unknown} x
+ * @returns {x is PanelResponse}
+ */
+function isPanelResponse(x) {
+  if (x === null || typeof x !== 'object') return false;
+  const o = /** @type {Record<string,unknown>} */ (x);
+  return (
+    typeof o.model === 'string' &&
+    typeof o.content === 'string' &&
+    typeof o.ok === 'boolean' &&
+    typeof o.durationMs === 'number' &&
+    typeof o.tokensEst === 'number'
+  );
+}
+
+/**
+ * @param {unknown} x
+ * @returns {x is Analysis}
+ */
+function isAnalysis(x) {
+  if (x === null || typeof x !== 'object') return false;
+  const o = /** @type {Record<string,unknown>} */ (x);
+  if (!Array.isArray(o.consensus)) return false;
+  if (!o.consensus.every(s => typeof s === 'string')) return false;
+  if (!Array.isArray(o.blind_spots)) return false;
+  if (!o.blind_spots.every(s => typeof s === 'string')) return false;
+  if (!Array.isArray(o.contradictions)) return false;
+  if (!o.contradictions.every(e => e !== null && typeof e === 'object')) return false;
+  if (!Array.isArray(o.partial_coverage)) return false;
+  if (!o.partial_coverage.every(e => e !== null && typeof e === 'object')) return false;
+  if (!Array.isArray(o.unique_insights)) return false;
+  if (!o.unique_insights.every(e => e !== null && typeof e === 'object')) return false;
+  return true;
+}
+
+/**
+ * @param {string} str
+ * @returns {Analysis}
+ * @throws {Error}
+ */
+function parseAnalysis(str) {
+  let parsed;
+  try {
+    parsed = JSON.parse(str);
+  } catch (e) {
+    throw new Error('parseAnalysis: invalid JSON — ' + e.message);
+  }
+  if (!isAnalysis(parsed)) {
+    throw new Error('parseAnalysis: object does not satisfy Analysis shape');
+  }
+  return /** @type {Analysis} */ (parsed);
+}
+
+/**
+ * @param {PanelResponse} panelResponse
+ * @returns {FailedModel}
+ */
+function toFailedModel(panelResponse) {
+  return { model: panelResponse.model, reason: panelResponse.error || 'unknown' };
+}
+
+/**
+ * @param {FailedModel[]} failedModels
+ * @returns {string}
+ */
+function classify(failedModels) {
+  if (!failedModels || failedModels.length === 0) return 'all_panels_failed';
+  const combined = failedModels.map(f => f.reason || '').join(' ').toLowerCase();
+  if (/rate.?limit|429|too many request/.test(combined)) return 'rate_limited';
+  if (/insufficient|credit|quota|billing|payment|exceed.*(usage|plan)/.test(combined)) return 'insufficient_credits';
+  if (/enoent|spawn|signal|crash|killed/.test(combined)) return 'unexpected_error';
+  return 'all_panels_failed';
+}
+
+// Port VERBATIM from scripts/compress.cjs — strips an outer ```fence
+// wrapping the ENTIRE output.
+function stripLlmWrapper(text) {
+  const m = text.match(/^\s*(`{3,}|~{3,})[^\n]*\n([\s\S]*)\n\1\s*$/);
+  return m ? m[2] : text;
+}
+
+module.exports = {
+  FAILURE_REASONS,
+  isPanelResponse,
+  isAnalysis,
+  parseAnalysis,
+  toFailedModel,
+  classify,
+  stripLlmWrapper,
+};

package/frontier/semaphore.cjs

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+// Maestro Frontier — bounded-concurrency map utility.
+// mapLimit(items, limit, asyncFn) -> Promise<settled[]>
+// Each settled item is {ok:true,value} or {ok:false,error}.
+// A rejected task releases its permit and does NOT starve the pool.
+
+'use strict';
+
+/**
+ * @template T, R
+ * @param {T[]} items
+ * @param {number} limit
+ * @param {(item: T, index: number) => Promise<R>} asyncFn
+ * @returns {Promise<({ok:true,value:R}|{ok:false,error:unknown})[]}
+ */
+function mapLimit(items, limit, asyncFn) {
+  return new Promise((resolve) => {
+    const n = items.length;
+    if (n === 0) { resolve([]); return; }
+
+    const results = new Array(n);
+    let nextIdx = 0;   // index of next item to start
+    let inFlight = 0;  // currently running tasks
+    let done = 0;      // settled tasks
+
+    function run() {
+      while (inFlight < limit && nextIdx < n) {
+        const idx = nextIdx++;
+        inFlight++;
+        Promise.resolve()
+          .then(() => asyncFn(items[idx], idx))
+          .then(
+            (value) => { results[idx] = { ok: true, value }; },
+            (error) => { results[idx] = { ok: false, error }; }
+          )
+          .finally(() => {
+            inFlight--;
+            done++;
+            if (done === n) { resolve(results); return; }
+            run();
+          });
+      }
+    }
+
+    run();
+  });
+}
+
+module.exports = { mapLimit };