@witchpot/gmc 0.1.8 → 0.2.0

package/src/workflows.js

@@ -25,12 +25,19 @@ export async function executeRequestPlan(baseUrl, request, { apiKey }) {
     return executeShowcaseFitRequest(baseUrl, request, { apiKey });
   }
 
-  const response = await fetchJson(createRequestUrl(baseUrl, request), { apiKey });
+  const response = await fetchJson(createRequestUrl(baseUrl, request), {
+    apiKey,
+    method: request.method,
+    body: request.body
+  });
   return request.transform ? request.transform(response) : response;
 }
 
 async function executeCohortEvidenceRequest(baseUrl, request, { apiKey }) {
-  const sampled = await executeSearchPages(baseUrl, request.searchRequest, request.sampling, { apiKey });
+  const [sampled, count] = await Promise.all([
+    executeSearchPages(baseUrl, request.searchRequest, request.sampling, { apiKey }),
+    fetchOptionalCount(baseUrl, request.countRequest, { apiKey })
+  ]);
   const search = mergeSearchPages(sampled.searches, request.sampling);
   const games = Array.isArray(search?.data) ? search.data : [];
   const analysisResults = request.analysisQuery
@@ -69,6 +76,7 @@ async function executeCohortEvidenceRequest(baseUrl, request, { apiKey }) {
 
   return composeCohortEvidencePayload(request, {
     search,
+    count,
     searches: sampled.searches,
     searchPageErrors: sampled.pageErrors,
     analysisResults
@@ -81,8 +89,11 @@ async function executeResolveRequest(baseUrl, request, { apiKey }) {
 }
 
 async function executeBenchmarkRequest(baseUrl, request, { apiKey }) {
-  const sampled = await executeSearchPages(baseUrl, request.searchRequest, request.sampling, { apiKey });
-  return composeBenchmarkPayload(request, sampled);
+  const [sampled, count] = await Promise.all([
+    executeSearchPages(baseUrl, request.searchRequest, request.sampling, { apiKey }),
+    fetchOptionalCount(baseUrl, request.countRequest, { apiKey })
+  ]);
+  return composeBenchmarkPayload(request, { ...sampled, count });
 }
 
 async function executeCompareRequest(baseUrl, request, { apiKey }) {
@@ -116,7 +127,10 @@ async function executeCompareRequest(baseUrl, request, { apiKey }) {
 }
 
 async function executeReviewPatternsRequest(baseUrl, request, { apiKey }) {
-  const sampled = await executeSearchPages(baseUrl, request.searchRequest, request.sampling, { apiKey });
+  const [sampled, count] = await Promise.all([
+    executeSearchPages(baseUrl, request.searchRequest, request.sampling, { apiKey }),
+    fetchOptionalCount(baseUrl, request.countRequest, { apiKey })
+  ]);
   const search = mergeSearchPages(sampled.searches, request.sampling);
   const games = Array.isArray(search?.data) ? search.data : [];
   const topicResults = await Promise.all(
@@ -153,6 +167,7 @@ async function executeReviewPatternsRequest(baseUrl, request, { apiKey }) {
 
   return composeReviewPatternsPayload(request, {
     search,
+    count,
     searches: sampled.searches,
     searchPageErrors: sampled.pageErrors,
     topicResults
@@ -205,12 +220,12 @@ async function executeShowcaseFitRequest(baseUrl, request, { apiKey }) {
 async function executeSearchPages(baseUrl, searchRequest, sampling, { apiKey }) {
   if (!sampling) {
     return {
-      searches: [await fetchJson(createRequestUrl(baseUrl, searchRequest), { apiKey })],
+      searches: [normalizeSearchEnvelope(await fetchJson(createRequestUrl(baseUrl, searchRequest), { apiKey }))],
       pageErrors: []
     };
   }
 
-  const firstSearch = await fetchJson(createRequestUrl(baseUrl, searchRequest), { apiKey });
+  const firstSearch = normalizeSearchEnvelope(await fetchJson(createRequestUrl(baseUrl, searchRequest), { apiKey }));
   const searches = [firstSearch];
   const pageErrors = [];
   let nextOffset = firstSearch?.pagination?.nextOffset;
@@ -233,8 +248,9 @@ async function executeSearchPages(baseUrl, searchRequest, sampling, { apiKey })
       break;
     }
 
-    searches.push(pageResult.payload);
-    nextOffset = pageResult.payload?.pagination?.nextOffset;
+    const normalizedPage = normalizeSearchEnvelope(pageResult.payload);
+    searches.push(normalizedPage);
+    nextOffset = normalizedPage?.pagination?.nextOffset;
   }
 
   return {
@@ -243,6 +259,23 @@ async function executeSearchPages(baseUrl, searchRequest, sampling, { apiKey })
   };
 }
 
+function normalizeSearchEnvelope(payload) {
+  if (Array.isArray(payload?.data?.games)) {
+    return {
+      ...payload,
+      data: payload.data.games,
+      list: payload.data.list,
+      notes: payload.data.notes
+    };
+  }
+  return payload;
+}
+
+async function fetchOptionalCount(baseUrl, countRequest, { apiKey }) {
+  if (!countRequest) return undefined;
+  return fetchJson(createRequestUrl(baseUrl, countRequest), { apiKey });
+}
+
 function shouldFetchNextSamplePage(sampling, searches) {
   if (sampling.mode === "sample-pages") return searches.length < sampling.requestedPages;
   const fetchedRows = searches.reduce((sum, search) => sum + asArray(search?.data).length, 0);
@@ -383,6 +416,8 @@ export function composeBenchmarkPayload(request, search, options = {}) {
     : search;
   const games = Array.isArray(mergedSearch?.data) ? mergedSearch.data : [];
   const sample = buildSampleMetadata(request, searches, games, pageErrors);
+  const totalMatches = getTotalMatches(search.count, mergedSearch?.pagination);
+  const pagination = withPaginationTotal(mergedSearch?.pagination, totalMatches);
 
   return {
     data: {
@@ -391,19 +426,19 @@ export function composeBenchmarkPayload(request, search, options = {}) {
       workflow: "gamesBenchmark",
       inputs: {
         filters: request.query,
-        ...(sample ? { sample: buildEvidencePackSample(sample, games.length) } : {
-          sample: buildReturnedPageSample(mergedSearch?.pagination, games.length)
+        ...(sample ? { sample: buildEvidencePackSample(sample, games.length, totalMatches) } : {
+          sample: buildReturnedPageSample(pagination, games.length, totalMatches)
         })
       },
       query: request.query,
       summary: withSummaryBasis(
-        buildBenchmarkSummary(games, mergedSearch?.pagination, request.source, { sampled: Boolean(sample) }),
+        buildBenchmarkSummary(games, pagination, request.source, { sampled: Boolean(sample) }),
         sample ? "bounded_sample" : "returned_page"
       ),
       ...(sample
         ? {
             sampledSummary: withSummaryBasis(
-              buildBenchmarkSummary(games, mergedSearch?.pagination, request.source, { sampled: true }),
+              buildBenchmarkSummary(games, pagination, request.source, { sampled: true }),
               "bounded_sample"
             )
           }
@@ -424,11 +459,15 @@ export function composeBenchmarkPayload(request, search, options = {}) {
       requestId,
       composedBy: "gmc-cli",
       ...(sample ? { sample } : {}),
-      upstreamRequests: buildSearchUpstreamRequests(searches, pageErrors)
+      upstreamRequests: [
+        ...buildSearchUpstreamRequests(searches, pageErrors),
+        ...buildCountUpstreamRequests(search.count)
+      ]
     },
-    ...(mergedSearch?.pagination ? { pagination: mergedSearch.pagination } : {}),
+    ...(pagination ? { pagination } : {}),
     warnings: uniqueStrings([
       ...searches.flatMap((entry) => safeWarnings(entry)),
+      ...safeWarnings(search.count),
       ...pageErrors.map((entry) => `benchmark sample page failed at offset ${entry.offset}: ${entry.error?.code ?? "CLI_API_ERROR"}`),
       sample
         ? "sampledSummary is computed from bounded sampled pages; it is not a full market-size estimate"
@@ -457,6 +496,7 @@ export function composeReviewPatternsPayload(request, result, options = {}) {
   const includedGames = normalizedGames.filter((game) => !game.skippedReason);
   const usableGames = includedGames.filter((game) => game.topics.length > 0);
   const sample = buildSampleMetadata(request, searches, games, searchPageErrors);
+  const totalMatches = getTotalMatches(result.count, result.search?.pagination);
   const skipped = normalizedGames
     .filter((game) => game.skippedReason)
     .map((game) => ({
@@ -469,6 +509,7 @@ export function composeReviewPatternsPayload(request, result, options = {}) {
     }));
   const warnings = uniqueStrings([
     ...safeWarnings(result.search),
+    ...safeWarnings(result.count),
     ...searches.flatMap((entry) => safeWarnings(entry)),
     ...searchPageErrors.map((entry) => `review pattern sample page failed at offset ${entry.offset}: ${entry.error?.code ?? "CLI_API_ERROR"}`),
     ...topicResults.flatMap((entry) => safeWarnings(entry.topics)),
@@ -491,8 +532,8 @@ export function composeReviewPatternsPayload(request, result, options = {}) {
         ...(request.topic ? { topic: request.topic } : {}),
         ...(request.compareBy ? { compareBy: request.compareBy } : {}),
         ...(sample
-          ? { sample: buildEvidencePackSample(sample, usableGames.length) }
-          : { sample: buildReturnedPageSample(result.search?.pagination, usableGames.length) })
+          ? { sample: buildEvidencePackSample(sample, usableGames.length, totalMatches) }
+          : { sample: buildReturnedPageSample(result.search?.pagination, usableGames.length, totalMatches) })
       },
       cohort: {
         query: request.query,
@@ -505,7 +546,7 @@ export function composeReviewPatternsPayload(request, result, options = {}) {
         usableGames: usableGames.length,
         skippedGames: skipped.length,
         skippedReasons: tallySkippedReasons(skipped),
-        totalMatches: result.search?.pagination?.total,
+        ...(typeof totalMatches === "number" ? { totalMatches } : {}),
         included: usableGames.map((game) => ({
           source: request.source,
           externalId: game.externalId,
@@ -521,7 +562,7 @@ export function composeReviewPatternsPayload(request, result, options = {}) {
         skipped
       },
       summary: withSummaryBasis(
-        buildReviewPatternsSummary(request, usableGames, skipped, result.search?.pagination),
+        buildReviewPatternsSummary(request, usableGames, skipped, withPaginationTotal(result.search?.pagination, totalMatches)),
         sample ? "bounded_sample" : "returned_page"
       ),
       patterns: buildReviewPatterns(usableGames),
@@ -547,6 +588,7 @@ export function composeReviewPatternsPayload(request, result, options = {}) {
       ...(sample ? { sample } : {}),
       upstreamRequests: [
         ...buildSearchUpstreamRequests(searches, searchPageErrors),
+        ...buildCountUpstreamRequests(result.count),
         ...topicResults
           .filter((entry) => entry.topics || entry.error)
           .map((entry) => ({
@@ -559,7 +601,7 @@ export function composeReviewPatternsPayload(request, result, options = {}) {
           }))
       ]
     },
-    ...(result.search?.pagination ? { pagination: result.search.pagination } : {}),
+    ...(result.search?.pagination ? { pagination: withPaginationTotal(result.search.pagination, totalMatches) } : {}),
     ...(warnings.length ? { warnings } : {})
   };
 }
@@ -657,7 +699,8 @@ export function composeCohortEvidencePayload(request, result, options = {}) {
   const searches = Array.isArray(result.searches) ? result.searches : [result.search];
   const searchPageErrors = Array.isArray(result.searchPageErrors) ? result.searchPageErrors : [];
   const analysisResults = Array.isArray(result.analysisResults) ? result.analysisResults : [];
-  const entries = analysisResults.map((entry) => buildCohortEvidenceGame(request, entry));
+  const listNotes = collectListNotes(searches);
+  const entries = analysisResults.map((entry) => buildCohortEvidenceGame(request, entry, listNotes));
   const included = entries.filter((entry) => !entry.skippedReason);
   const skipped = entries
     .filter((entry) => entry.skippedReason)
@@ -670,8 +713,10 @@ export function composeCohortEvidencePayload(request, result, options = {}) {
       ...(entry.error ? { error: entry.error } : {})
     }));
   const sample = buildSampleMetadata(request, searches, games, searchPageErrors);
+  const totalMatches = getTotalMatches(result.count, result.search?.pagination);
   const warnings = uniqueStrings([
     ...safeWarnings(result.search),
+    ...safeWarnings(result.count),
     ...searches.flatMap((entry) => safeWarnings(entry)),
     ...searchPageErrors.map((entry) => `${request.workflow} sample page failed at offset ${entry.offset}: ${entry.error?.code ?? "CLI_API_ERROR"}`),
     ...analysisResults.flatMap((entry) => safeWarnings(entry.analysis)),
@@ -688,8 +733,8 @@ export function composeCohortEvidencePayload(request, result, options = {}) {
       inputs: {
         filters: request.query,
         sections: request.sections,
-        ...(sample ? { sample: buildEvidencePackSample(sample, included.length) } : {
-          sample: buildReturnedPageSample(result.search?.pagination, included.length)
+        ...(sample ? { sample: buildEvidencePackSample(sample, included.length, totalMatches) } : {
+          sample: buildReturnedPageSample(result.search?.pagination, included.length, totalMatches)
         })
       },
       cohort: {
@@ -698,7 +743,7 @@ export function composeCohortEvidencePayload(request, result, options = {}) {
         usableGames: included.length,
         skippedGames: skipped.length,
         skippedReasons: tallySkippedReasons(skipped),
-        totalMatches: result.search?.pagination?.total,
+        ...(typeof totalMatches === "number" ? { totalMatches } : {}),
         included: included.map((entry) => ({
           source: request.source,
           externalId: entry.externalId,
@@ -710,18 +755,19 @@ export function composeCohortEvidencePayload(request, result, options = {}) {
             releaseDate: entry.releaseDate,
             coverage: entry.coverage,
             tags: entry.tags,
+            ...(entry.listNote ? { listNote: entry.listNote } : {}),
             patternEvidence: entry.patternEvidence
           }
         })),
         skipped
       },
       summary: withSummaryBasis(
-        buildCohortEvidenceSummary(request, included, result.search?.pagination),
+        buildCohortEvidenceSummary(request, included, withPaginationTotal(result.search?.pagination, totalMatches)),
         sample ? "bounded_sample" : "returned_page"
       ),
       patterns: buildCohortEvidencePatterns(request, included),
       ...(request.evidenceType === "pricing" ? { segments: buildPricingSegments(included) } : {}),
-      ...(request.evidenceType === "trends" || request.evidenceType === "brief" ? { trends: buildTrendSummary(included, result.search?.pagination, request.source) } : {}),
+      ...(request.evidenceType === "trends" || request.evidenceType === "brief" ? { trends: buildTrendSummary(included, withPaginationTotal(result.search?.pagination, totalMatches), request.source) } : {}),
       games: included.map((entry) => ({
         source: request.source,
         externalId: entry.externalId,
@@ -733,6 +779,7 @@ export function composeCohortEvidencePayload(request, result, options = {}) {
         releaseDate: entry.releaseDate,
         coverage: entry.coverage,
         tags: entry.tags,
+        ...(entry.listNote ? { listNote: entry.listNote } : {}),
         patternEvidence: entry.patternEvidence
       })),
       skipped
@@ -744,6 +791,7 @@ export function composeCohortEvidencePayload(request, result, options = {}) {
       ...(sample ? { sample } : {}),
       upstreamRequests: [
         ...buildSearchUpstreamRequests(searches, searchPageErrors),
+        ...buildCountUpstreamRequests(result.count),
         ...analysisResults
           .filter((entry) => entry.analysis || entry.error)
           .map((entry) => ({
@@ -756,7 +804,7 @@ export function composeCohortEvidencePayload(request, result, options = {}) {
           }))
       ]
     },
-    ...(result.search?.pagination ? { pagination: result.search.pagination } : {}),
+    ...(result.search?.pagination ? { pagination: withPaginationTotal(result.search.pagination, totalMatches) } : {}),
     ...(warnings.length ? { warnings } : {})
   };
 }
@@ -826,11 +874,16 @@ export function composeShowcaseFitPayload(request, result, options = {}) {
   };
 }
 
-async function fetchJson(url, { apiKey }) {
+async function fetchJson(url, { apiKey, method = "GET", body } = {}) {
   let response;
   try {
     response = await fetch(url, {
-      headers: buildRequestHeaders(apiKey)
+      method,
+      headers: {
+        ...buildRequestHeaders(apiKey),
+        ...(body == null ? {} : { "content-type": "application/json" })
+      },
+      ...(body == null ? {} : { body: JSON.stringify(body) })
     });
   } catch (error) {
     writeJsonError({
@@ -1021,7 +1074,7 @@ function mergeSearchPages(searches, sampling) {
       ...(first.pagination ?? {}),
       limit: first.pagination?.limit,
       offset: first.pagination?.offset,
-      total: first.pagination?.total,
+      ...(typeof first.pagination?.total === "number" ? { total: first.pagination.total } : {}),
       nextOffset: last.pagination?.nextOffset
     },
     warnings: uniqueStrings(searches.flatMap((search) => safeWarnings(search)))
@@ -1038,12 +1091,12 @@ function buildSampleMetadata(request, searches, games, pageErrors) {
     fetchedPages: searches.length,
     fetchedGames: games.length,
     skippedPages: pageErrors.length,
-    totalMatches: searches[0]?.pagination?.total,
+    ...(typeof searches[0]?.pagination?.total === "number" ? { totalMatches: searches[0].pagination.total } : {}),
     quotaCaveat: "Sampled workflows issue one search request per fetched page, plus downstream per-game requests when the command needs detail evidence."
   };
 }
 
-function buildEvidencePackSample(sample, returnedRows) {
+function buildEvidencePackSample(sample, returnedRows, totalMatches) {
   return {
     mode: normalizeEvidencePackSampleMode(sample.mode),
     requestedRows: sample.requestedSize,
@@ -1051,16 +1104,31 @@ function buildEvidencePackSample(sample, returnedRows) {
     returnedRows,
     fetchedPages: sample.fetchedPages,
     skippedPages: sample.skippedPages,
-    totalMatches: sample.totalMatches
+    totalMatches: typeof totalMatches === "number" ? totalMatches : sample.totalMatches
   };
 }
 
-function buildReturnedPageSample(pagination, returnedRows) {
+function buildReturnedPageSample(pagination, returnedRows, totalMatches) {
   return {
     mode: "returned_page",
     requestedRows: pagination?.limit,
     returnedRows,
-    totalMatches: pagination?.total
+    totalMatches: typeof totalMatches === "number" ? totalMatches : pagination?.total
+  };
+}
+
+function getTotalMatches(count, pagination) {
+  const countValue = numericValue(count?.data?.count);
+  if (Number.isFinite(countValue)) return countValue;
+  const paginationTotal = numericValue(pagination?.total);
+  return Number.isFinite(paginationTotal) ? paginationTotal : undefined;
+}
+
+function withPaginationTotal(pagination, totalMatches) {
+  if (typeof totalMatches !== "number") return pagination;
+  return {
+    ...(pagination ?? {}),
+    total: totalMatches
   };
 }
 
@@ -1096,6 +1164,17 @@ function buildSearchUpstreamRequests(searches, pageErrors = []) {
   ];
 }
 
+function buildCountUpstreamRequests(count) {
+  if (!count) return [];
+  return [{
+    kind: "count",
+    requestId: count?.meta?.requestId,
+    source: count?.meta?.source,
+    entitlements: count?.meta?.entitlements,
+    count: count?.data?.count
+  }];
+}
+
 function buildReviewPatternGame(request, entry) {
   const game = entry.game ?? {};
   const externalId = asString(entry.externalId ?? game?.externalId ?? game?.appid);
@@ -1303,7 +1382,7 @@ function buildReviewPatternSegments(games, segment) {
     }));
 }
 
-function buildCohortEvidenceGame(request, entry) {
+function buildCohortEvidenceGame(request, entry, listNotes = new Map()) {
   const game = entry.game ?? {};
   const externalId = asString(entry.externalId ?? game?.externalId ?? game?.appid);
   const sections = getAnalysisSections(entry.analysis);
@@ -1324,6 +1403,7 @@ function buildCohortEvidenceGame(request, entry) {
     coverage: game?.coverage,
     tags: getRankedTagNames(game).slice(0, 8),
     genres: game?.genres,
+    listNote: lookupListNote(listNotes, game?.appid, externalId),
     analysis: entry.analysis,
     sections,
     patternEvidence,
@@ -1332,6 +1412,23 @@ function buildCohortEvidenceGame(request, entry) {
   };
 }
 
+function collectListNotes(searches) {
+  const notes = new Map();
+  for (const search of searches) {
+    if (!search?.notes || typeof search.notes !== "object") continue;
+    for (const [appid, note] of Object.entries(search.notes)) {
+      if (typeof note === "string" && note.trim()) notes.set(String(appid), note);
+    }
+  }
+  return notes;
+}
+
+function lookupListNote(notes, appid, externalId) {
+  if (!notes?.size) return undefined;
+  const appidKey = appid == null ? undefined : String(appid);
+  return (appidKey ? notes.get(appidKey) : undefined) ?? (externalId ? notes.get(String(externalId)) : undefined);
+}
+
 function buildCohortEvidenceSummary(request, entries, pagination) {
   return {
     sampleSize: entries.length,

package/src/workflows.test.js

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 
-import { composeCohortEvidencePayload } from "./workflows.js";
+import { composeBenchmarkPayload, composeCohortEvidencePayload, executeRequestPlan } from "./workflows.js";
 
 test("cohort evidence summarizes skipped games by reason", () => {
   const request = {
@@ -78,3 +78,85 @@ test("cohort evidence reports an empty reason tally when nothing is skipped", ()
 
   assert.deepEqual(payload.data.cohort.skippedReasons, {});
 });
+
+test("benchmark attaches exact total only when a count response is supplied", () => {
+  const request = {
+    source: "steam",
+    query: { sort: "reviews_desc", limit: 20, includeTotal: false }
+  };
+  const payload = composeBenchmarkPayload(request, {
+    searches: [{
+      data: [{ appid: 1, title: "Usable", reviews: 100 }],
+      pagination: { limit: 20, offset: 0, nextOffset: 20 },
+      meta: { requestId: "search_req", source: "steam-analysis" }
+    }],
+    pageErrors: [],
+    count: {
+      data: { count: 123 },
+      meta: { requestId: "count_req", source: "steam-analysis" }
+    }
+  }, {
+    generatedAt: "2026-06-12T00:00:00.000Z",
+    requestId: "req_test"
+  });
+
+  assert.equal(payload.data.summary.totalMatches, 123);
+  assert.equal(payload.data.inputs.sample.totalMatches, 123);
+  assert.equal(payload.pagination.total, 123);
+  assert.deepEqual(payload.meta.upstreamRequests.map((entry) => entry.kind), ["search", "count"]);
+});
+
+test("executeRequestPlan normalizes list game resolution for cohort workflows", async () => {
+  const originalFetch = globalThis.fetch;
+  const seenUrls = [];
+  globalThis.fetch = async (url) => {
+    seenUrls.push(String(url));
+    if (String(url).includes("/analysis")) {
+      return jsonResponse({
+        data: { appid: 730, sections: {} },
+        meta: { requestId: "analysis_req" }
+      });
+    }
+    return jsonResponse({
+      data: {
+        list: { id: "list-1", name: "Competitors", kind: "manual" },
+        games: [{ appid: 730, externalId: "730", title: "Example", reviews: 100 }],
+        notes: { 730: "Positioning reference" }
+      },
+      pagination: { limit: 20, offset: 0, total: 1, nextOffset: null },
+      meta: { requestId: "list_req", source: "static-fixture" }
+    });
+  };
+
+  try {
+    const payload = await executeRequestPlan("https://gmc.test", {
+      kind: "cohortEvidence",
+      source: "steam",
+      workflow: "cohortTrends",
+      evidenceType: "trends",
+      sections: [],
+      query: { list: "list-1", limit: "20" },
+      searchRequest: {
+        path: "/api/v1/lists/list-1/games",
+        query: { list: "list-1", limit: "20" }
+      }
+    }, { apiKey: "gmck_test" });
+
+    assert.equal(payload.data.cohort.returnedGames, 1);
+    assert.equal(payload.data.cohort.included[0].externalId, "730");
+    assert.equal(payload.data.cohort.included[0].evidence.listNote, "Positioning reference");
+    assert.equal(payload.data.games[0].listNote, "Positioning reference");
+    assert.ok(seenUrls.some((url) => url.includes("/api/v1/lists/list-1/games")));
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+function jsonResponse(payload, status = 200) {
+  return {
+    ok: status >= 200 && status < 300,
+    status,
+    headers: new Headers({ "content-type": "application/json" }),
+    json: async () => payload
+  };
+}