@koda-sl/baker-cli 0.524.0 → 0.525.0

package/dist/feedback-record-DR6PXCBL.js

@@ -0,0 +1,265 @@
+import {
+  modelRuleDrafter,
+  repeatedReasons,
+  ruleCandidateHints,
+  ruleCandidates,
+  saveCandidates
+} from "./chunk-ILYJWV7K.js";
+import {
+  versionOf
+} from "./chunk-VQYBXI76.js";
+import {
+  readCreativeIdea,
+  withAnchor
+} from "./chunk-PKJZ42PC.js";
+import "./chunk-TUJBT5IT.js";
+import "./chunk-QT2W5VGG.js";
+import "./chunk-QNWDGKGN.js";
+import "./chunk-ED3OAFEO.js";
+import "./chunk-XZLGG2AT.js";
+import "./chunk-XCHIV2EE.js";
+import "./chunk-EKX37C3T.js";
+import "./chunk-NBVQBVLL.js";
+import "./chunk-N727QO5G.js";
+import {
+  frontmatterOf
+} from "./chunk-IGG52H7X.js";
+import "./chunk-6WI5SJ3A.js";
+import "./chunk-XJL6ECNN.js";
+import "./chunk-KL4H62CA.js";
+import "./chunk-4E5FSFXV.js";
+import {
+  holdWorkspaceSpend
+} from "./chunk-TMVNSRSX.js";
+import {
+  findWorkspaceRoot
+} from "./chunk-ER3V3FVG.js";
+import "./chunk-EBMIK6PP.js";
+import "./chunk-5QRF7ANY.js";
+import "./chunk-DGCUPJZD.js";
+import "./chunk-HQWSGOAC.js";
+import "./chunk-AEUKCVG6.js";
+import "./chunk-SGEHQTEJ.js";
+import "./chunk-MCJ5I5LR.js";
+import "./chunk-2WZI36D3.js";
+import "./chunk-65Y3RCWP.js";
+import {
+  askJev
+} from "./chunk-DGWSMAKI.js";
+import "./chunk-TCYK35RZ.js";
+import "./chunk-G2NUIZ74.js";
+import "./chunk-OMORXBRN.js";
+import {
+  CREATIVE_FEEDBACK_REASONS,
+  creativesFeedbackRecordRequestSchema
+} from "./chunk-HVJJEQDQ.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-NSBNIPIW.js";
+import "./chunk-46YLDIQG.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-DPPV45D5.js";
+import "./chunk-DERQLVKB.js";
+import "./chunk-ABXVFHTG.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-UCI6ZGUF.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/creatives/feedback-record.ts
+import { readFile } from "fs/promises";
+import path from "path";
+import { defineCommand } from "citty";
+
+// src/commands/creatives/agent-option-note.ts
+var NOTE_BANDS = { tagged: 0.5, bareFix: 0.45, namesProblem: 0.5 };
+var TAGGED = "Does `note` end with a tag marking it as the recommended option, like (Recommended), in any language?";
+var BARE_FIX = 'Is `note` a bare yes to an offer to fix things, like "fix everything" or "fix what is pending", naming no particular problem? A note that names what is wrong or what to change (the typos, the price, cut-off text, redo the pieces) is not.';
+var NAMES_PROBLEM = "Does `note` name a particular problem, element or part of an ad (a typo, the price, the logo, the audio, the text, the colours, a person), apart from a whole format or size?";
+var jevNoteJudge = async (note) => {
+  const spent = [];
+  const answers = await askJev(
+    [TAGGED, BARE_FIX, NAMES_PROBLEM].map((question) => ({ instructions: { note, question } })),
+    (usage) => spent.push(usage)
+  );
+  await holdWorkspaceSpend(spent);
+  if (answers === null) return null;
+  const [tagged = 0, bareFix = 0, namesProblem = 1] = answers;
+  return { tagged, bareFix, namesProblem };
+};
+function readsAsAgentOption(reading) {
+  if (reading.tagged >= NOTE_BANDS.tagged) return true;
+  return reading.bareFix >= NOTE_BANDS.bareFix && reading.namesProblem < NOTE_BANDS.namesProblem;
+}
+async function readNoteAuthor(note, judge) {
+  const text = note.trim();
+  if (!text) return "person";
+  const reading = await judge(text).catch(() => null);
+  if (reading === null) return "unconfirmed";
+  return readsAsAgentOption(reading) ? "agent_option" : "person";
+}
+
+// src/commands/creatives/feedback-record.ts
+var DESCRIPTION = `Record what the user said about one version of a creative in this chat: an approval, or a rejection with reasons. Saved as their verdict (the person who wrote the latest message here) and read back by baker creatives feedback. One verdict per person per version or option: a later one replaces it.
+Start here: baker creatives feedback record --slug spring-offer --verdict rejected --reasons text_mistakes --note "<their words>"
+Only record what the user said, never your own judgment. Picking one of several concepts is not a rejection of the others.
+When their words state a rule for every ad, the answer carries ruleCandidates: ask them once, and only on yes run baker creatives rules add --candidate <id>.
+A rejection's answer carries the creative's idea as data.anchor (its message, reference and language), restated first in hints: the edit keeps it, changing only what they named.`;
+var ARGS = {
+  slug: { type: "string", description: "The creative: its folder name under src/creatives/.", required: true },
+  run: {
+    type: "string",
+    description: "The version: its canvas run id (r_\u2026) Left out, the version the creative shows now (its last render).",
+    required: false
+  },
+  option: {
+    type: "string",
+    description: 'One option of a version that made several: its label ("ugc"), its number ("2") or its slot. Left out, the whole version.',
+    required: false
+  },
+  verdict: { type: "string", description: "approved | rejected", required: true },
+  reasons: {
+    type: "string",
+    description: `Why it was rejected, comma-separated: ${CREATIVE_FEEDBACK_REASONS.join(", ")}. Map the user's words to these; "other" when none fits. On a video, voice_or_sound covers the voiceover, music and mix ("the voice sounds robotic", "music too loud") and pacing covers the timing ("too slow", "the hook comes too late").`,
+    required: false
+  },
+  note: {
+    type: "string",
+    description: "The user's own words, verbatim (not your summary). Up to 1000 characters.",
+    required: false
+  }
+};
+registerSchema({ command: "creatives.feedback.record", description: DESCRIPTION, args: ARGS });
+function splitList(value) {
+  if (typeof value !== "string" || value.trim() === "") return void 0;
+  return value.split(",").map((item) => item.trim()).filter((item) => item.length > 0);
+}
+function fail(code, message) {
+  writeJson({ ok: false, error: { code, message } });
+  process.exit(1);
+}
+async function refuseNotFeedback(body) {
+  if (body.verdict === "rejected" && !body.reasons?.length && !body.note) {
+    fail(
+      "VALIDATION_ERROR",
+      "A rejection needs --reasons or --note (the user's words), so the next version knows what to change."
+    );
+  }
+  if (body.verdict !== "rejected" || !body.note) return false;
+  const author = await readNoteAuthor(body.note, jevNoteJudge);
+  if (author === "agent_option") {
+    fail(
+      "AGENT_OPTION_NOT_FEEDBACK",
+      `"${body.note}" is the answer to your own question, not the person's taste: a defect the checks found is yours to fix inside this version (\`baker canvas run --fix\`), never feedback to record. Record only what the person says about the ad in their own words.`
+    );
+  }
+  return author === "unconfirmed";
+}
+async function writeBack(body) {
+  const root = findWorkspaceRoot(process.cwd()) ?? process.cwd();
+  const cacheDir = path.join(root, "canvas", ".cache");
+  const definition = frontmatterOf(
+    await readFile(path.join(root, "src", "creatives", body.slug, "_definition.md"), "utf8").catch(() => "")
+  );
+  const kind = definition?.kind === "video" || definition?.kind === "static" ? definition.kind : void 0;
+  const platform = typeof definition?.platform === "string" ? definition.platform : void 0;
+  const [drafts, company] = await Promise.all([
+    ruleCandidates(
+      body.note,
+      { ...kind ? { kind } : {}, ...platform ? { platform } : {} },
+      modelRuleDrafter(cacheDir)
+    ),
+    // Every recent verdict, notes whole: the distinct-notes summary counts a note given on five ads once.
+    apiPost("/api/creatives/feedback", { full: true }).catch(() => null)
+  ]);
+  const saved = drafts.map((d) => ({
+    ...d,
+    source: { slug: body.slug, runId: body.runId, ...body.note ? { quote: body.note } : {} }
+  }));
+  const ids = await saveCandidates(cacheDir, saved).catch(() => []);
+  const offered = drafts.flatMap((d, i) => ids[i] ? [{ id: ids[i], draft: d }] : []);
+  const rejections = (company?.data.recent ?? []).flatMap(
+    (e) => e.verdict === "rejected" && e.note ? [{ creative: e.creative, reasons: e.reasons, note: e.note }] : []
+  );
+  const repeated = repeatedReasons(rejections, body.reasons ?? [], body.slug);
+  return {
+    candidates: offered.map(({ id, draft }) => ({
+      candidate: id,
+      rule: draft.text,
+      strength: draft.strength,
+      applies: draft.applies,
+      ...draft.forbid ? { forbid: draft.forbid } : {},
+      ...draft.platforms ? { platforms: draft.platforms } : {}
+    })),
+    hints: ruleCandidateHints(
+      offered.map(({ id, draft }) => ({ id, text: draft.text })),
+      repeated
+    )
+  };
+}
+async function withRules(response, body, noteUnconfirmed) {
+  if (body.verdict !== "rejected" || !body.note || noteUnconfirmed) return response;
+  const rule = await writeBack(body);
+  return {
+    ...response,
+    data: { ...response.data, ...rule.candidates.length > 0 ? { ruleCandidates: rule.candidates } : {} },
+    hints: [...response.hints ?? [], ...rule.hints]
+  };
+}
+function ideaToKeep(body) {
+  return body.verdict === "rejected" ? readCreativeIdea(body.slug).catch(() => null) : Promise.resolve(null);
+}
+async function withIdea(recorded, idea) {
+  const view = await idea;
+  return view ? withAnchor(recorded, view, { full: false }) : recorded;
+}
+var feedbackRecordCommand = defineCommand({
+  meta: { name: "record", description: DESCRIPTION },
+  args: ARGS,
+  run: async ({ args }) => {
+    const reasons = splitList(args.reasons);
+    const unknown = (reasons ?? []).filter(
+      (reason) => !CREATIVE_FEEDBACK_REASONS.includes(reason)
+    );
+    if (unknown.length > 0) {
+      fail("VALIDATION_ERROR", `Unknown reason ${unknown.join(", ")}. Use: ${CREATIVE_FEEDBACK_REASONS.join(", ")}.`);
+    }
+    const parsed = creativesFeedbackRecordRequestSchema.safeParse({
+      slug: args.slug,
+      runId: await versionOf(String(args.slug), args.run).then(
+        (run) => run ?? fail("VALIDATION_ERROR", "--run: this creative has no rendered version here; name one (r_\u2026).")
+      ),
+      ...typeof args.option === "string" && args.option.trim() ? { option: args.option.trim() } : {},
+      verdict: args.verdict,
+      ...reasons ? { reasons } : {},
+      ...typeof args.note === "string" && args.note.trim() ? { note: args.note } : {}
+    });
+    if (!parsed.success) {
+      const issue = parsed.error.issues[0];
+      fail("VALIDATION_ERROR", `--${String(issue?.path[0] ?? "args")}: ${issue?.message ?? "invalid"}`);
+    }
+    const body = parsed.data;
+    const noteUnconfirmed = await refuseNotFeedback(body);
+    const idea = ideaToKeep(body);
+    try {
+      const response = await apiPost(
+        "/api/creatives/feedback/record",
+        noteUnconfirmed ? { ...body, noteUnconfirmed } : body
+      );
+      writeJson(await withIdea(await withRules(response, body, noteUnconfirmed), idea));
+    } catch (err) {
+      if (err instanceof ApiError) fail(err.code, err.message);
+      fail("INTERNAL_ERROR", "Unexpected error");
+    }
+  }
+});
+export {
+  feedbackRecordCommand
+};
+//# sourceMappingURL=feedback-record-DR6PXCBL.js.map

package/dist/fetch-CN3XY65Y.js

@@ -0,0 +1,139 @@
+import {
+  MAX_VIDEO_INGEST_SECONDS,
+  downloadTimeoutMs,
+  refuseByDuration
+} from "./chunk-FKOECEVC.js";
+import {
+  YtDlpError,
+  durationSeconds,
+  isAudioOnly,
+  probeYtDlp,
+  runYtDlp
+} from "./chunk-G2NUIZ74.js";
+import {
+  captureVimeoCookie
+} from "./chunk-ABXVFHTG.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-UCI6ZGUF.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/videos/fetch.ts
+import { constants } from "fs";
+import { copyFile, mkdir, mkdtemp, rm } from "fs/promises";
+import { tmpdir } from "os";
+import path from "path";
+import { defineCommand } from "citty";
+registerSchema({
+  command: "videos.fetch",
+  description: "Download a video page (YouTube, TikTok, Vimeo, \u2026) to a local .mp4 without adding it to the library. For editing a clip locally; use `videos ingest` to add one to the library.",
+  args: {
+    url: { type: "string", description: "Video page URL", required: true },
+    out: { type: "string", description: "Directory to write the file into (created if missing)", required: true },
+    "max-seconds": {
+      type: "string",
+      description: `Refuse videos longer than this many seconds (default ${MAX_VIDEO_INGEST_SECONDS})`,
+      required: false
+    },
+    "timeout-ms": { type: "string", description: "Download time limit in milliseconds", required: false },
+    "max-height": {
+      type: "string",
+      description: "Keep a version whose shorter side is at most this many pixels (e.g. 1080 \u2014 a vertical Short keeps 1080\xD71920) when the site offers one",
+      required: false
+    }
+  }
+});
+function positiveInt(value) {
+  const parsed = typeof value === "string" ? Number.parseInt(value, 10) : Number.NaN;
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : void 0;
+}
+var fetchCommand = defineCommand({
+  meta: {
+    name: "fetch",
+    description: "Download a video page to a local .mp4 without adding it to the library. Same downloader as `ingest` (proxy fallback, duration check).\n\nExample: baker videos fetch https://www.youtube.com/watch?v=abc123 --out ./clips"
+  },
+  args: {
+    url: { type: "positional", description: "Video page URL", required: true },
+    out: { type: "string", description: "Directory to write the file into", required: true },
+    "max-seconds": { type: "string", description: "Refuse videos longer than this", required: false },
+    "timeout-ms": { type: "string", description: "Download time limit in milliseconds", required: false },
+    "max-height": {
+      type: "string",
+      description: "Cap the shorter side at this many pixels (e.g. 1080)",
+      required: false
+    }
+  },
+  run: async ({ args }) => {
+    const result = await fetchVideo({
+      url: String(args.url ?? ""),
+      out: String(args.out ?? ""),
+      maxSeconds: positiveInt(args["max-seconds"]),
+      timeoutMs: positiveInt(args["timeout-ms"]),
+      maxHeight: positiveInt(args["max-height"])
+    });
+    writeJson(result);
+    if (!result.ok) process.exit(1);
+  }
+});
+async function fetchVideo(args) {
+  const outDir = path.resolve(args.out);
+  const workDir = await mkdtemp(path.join(tmpdir(), "videos-fetch-"));
+  try {
+    await mkdir(outDir, { recursive: true });
+    const vimeoCookie = captureVimeoCookie();
+    const probe = await probeYtDlp({ url: args.url, vimeoCookie, cookieDir: workDir });
+    if (isAudioOnly(probe.info)) {
+      return { ok: false, error: { code: "VALIDATION_ERROR", message: "That link is audio, not video." } };
+    }
+    const seconds = durationSeconds(probe.info);
+    const tooLong = refuseByDuration(seconds, args.maxSeconds ?? MAX_VIDEO_INGEST_SECONDS);
+    if (tooLong) {
+      return { ok: false, error: { code: "VALIDATION_ERROR", message: tooLong } };
+    }
+    const { filePath, tier, reducedQuality } = await runYtDlp({
+      url: args.url,
+      audioOnly: false,
+      workDir,
+      vimeoCookie,
+      timeoutMs: args.timeoutMs ?? downloadTimeoutMs(seconds),
+      maxHeight: args.maxHeight
+    });
+    return {
+      ok: true,
+      data: {
+        file: await placeInto(outDir, filePath, fileStem(probe.info)),
+        durationSeconds: seconds,
+        egress: tier,
+        ...reducedQuality ? { reducedQuality: true } : {}
+      }
+    };
+  } catch (err) {
+    const message = err instanceof YtDlpError ? `${err.message}: ${err.stderrTail}`.trim() : err instanceof Error ? err.message : String(err);
+    return { ok: false, error: { code: "DOWNLOAD_FAILED", message } };
+  } finally {
+    await rm(workDir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+function fileStem(info) {
+  const parts = [info.extractor_key, info.id].filter((part) => typeof part === "string" && part !== "");
+  const stem = parts.join("-").toLowerCase().replace(/[^a-z0-9._-]+/g, "_").replace(/^[._-]+/, "");
+  return stem === "" ? "video" : stem;
+}
+async function placeInto(outDir, source, stem) {
+  for (let n = 1; ; n++) {
+    const target = path.join(outDir, `${stem}${n === 1 ? "" : `-${n}`}${path.extname(source)}`);
+    try {
+      await copyFile(source, target, constants.COPYFILE_EXCL);
+      return target;
+    } catch (err) {
+      if (!(err instanceof Error && "code" in err && err.code === "EEXIST")) throw err;
+    }
+  }
+}
+export {
+  fetchCommand,
+  fetchVideo
+};
+//# sourceMappingURL=fetch-CN3XY65Y.js.map

package/dist/fetch-L2X4J6NL.js

@@ -0,0 +1,179 @@
+import {
+  fetchHints,
+  redditPageFix
+} from "./chunk-WWLZ5RRU.js";
+import {
+  handleResearchError,
+  writeResearchJson
+} from "./chunk-HZRJ2G6Z.js";
+import "./chunk-HVJJEQDQ.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-NSBNIPIW.js";
+import "./chunk-46YLDIQG.js";
+import {
+  apiPost
+} from "./chunk-DPPV45D5.js";
+import "./chunk-DERQLVKB.js";
+import "./chunk-ABXVFHTG.js";
+import {
+  registerSchema
+} from "./chunk-UCI6ZGUF.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/research/fetch.ts
+import { defineCommand } from "citty";
+var CONTENT_PREVIEW_CHARS = 2e4;
+var TIMEOUT_MS = 18e4;
+registerSchema({
+  command: "research.fetch",
+  description: "Read a page an ordinary web fetch could not \u2014 bot walls and JavaScript-rendered pages are resolved for you. Use it when your normal page read came back with a security check, an error page, or an empty shell.",
+  args: {
+    url: { type: "string", description: "Full URL of the page to read", required: true },
+    format: {
+      type: "string",
+      description: "markdown (default, best for reading) or html (when you need the markup)",
+      required: false,
+      enum: ["markdown", "html"]
+    },
+    "wait-for": {
+      type: "number",
+      description: "Extra ms to let late content settle (0-30000). Only for pages that fill in after load",
+      required: false
+    },
+    "whole-page": {
+      type: "boolean",
+      description: "Include nav, footer and sidebars (default: main content only)",
+      required: false,
+      default: false
+    },
+    full: {
+      type: "boolean",
+      description: `Return the whole page instead of the first ${CONTENT_PREVIEW_CHARS} characters`,
+      required: false,
+      default: false
+    }
+  }
+});
+var FIELDS = {
+  url: "The URL as asked for",
+  final_url: "Where the read landed after redirects",
+  title: "Page title, or null when the page declares none",
+  content: "The page text (markdown by default)",
+  content_chars: "Length of the full page available on the server",
+  content_shown: "Characters in `content` \u2014 below content_chars unless --full",
+  truncated: "The page was longer than one read returns, so the tail is missing",
+  provider: "Who resolved the read"
+};
+function fetchFix(code) {
+  if (code === "VALIDATION_ERROR") {
+    return {
+      action: "retry_with_changes",
+      explanation: "Re-run with a complete address, including https://."
+    };
+  }
+  if (code === "TIMEOUT") {
+    return {
+      action: "retry_with_changes",
+      explanation: "The page never settled. Retry this URL once with `--wait-for 10000`; if that fails too, carry on with the rest of the job and say this page couldn't be read."
+    };
+  }
+  if (code === "RATE_LIMITED") {
+    return {
+      action: "continue_without",
+      explanation: "The page reader is busy. Do the rest of the job first and come back to this URL once, later \u2014 don't loop on it."
+    };
+  }
+  if (code === "FORBIDDEN" || code === "NOT_FOUND") {
+    return {
+      action: "continue_without",
+      explanation: "This page will not open for us, and retrying will not change that. Carry on with the sources you can reach and say plainly which page you couldn't read."
+    };
+  }
+  return {
+    action: "continue_without",
+    explanation: "This read failed. Don't build a retry ladder around it \u2014 finish the rest of the job with what you can reach and name this page as a gap."
+  };
+}
+var fetchCommand = defineCommand({
+  meta: {
+    name: "fetch",
+    description: `Read a page an ordinary web fetch could not. Bot walls and JavaScript-rendered pages are resolved for you \u2014 you never have to retry, wait, or drive a browser yourself.
+
+Reach for this the moment a normal page read comes back with a security check, an error page, or an empty shell. One call, no escalation ladder.
+
+Examples:
+  baker research fetch "https://competitor.com/pricing"
+  baker research fetch "https://competitor.com/pricing" --full
+  baker research fetch "https://app.competitor.com/blog/post" --wait-for 5000
+  baker research fetch "https://competitor.com" --format html --whole-page`
+  },
+  args: {
+    url: { type: "positional", description: "URL of the page to read", required: false },
+    format: { type: "string", description: "markdown (default) or html", required: false },
+    "wait-for": { type: "string", description: "Extra ms to let late content settle (0-30000)", required: false },
+    "whole-page": { type: "boolean", description: "Include nav, footer and sidebars", required: false },
+    full: { type: "boolean", description: "Return the whole page, not just the first chunk", required: false }
+  },
+  run: async ({ args }) => {
+    const url = args.url;
+    if (!url) {
+      writeResearchJson({
+        ok: false,
+        error: {
+          code: "VALIDATION_ERROR",
+          message: "A URL is required",
+          fix: fetchFix("VALIDATION_ERROR")
+        }
+      });
+      process.exit(1);
+    }
+    const format = args.format ?? "markdown";
+    if (format !== "markdown" && format !== "html") {
+      writeResearchJson({
+        ok: false,
+        error: {
+          code: "VALIDATION_ERROR",
+          message: "Format must be markdown or html",
+          fix: { action: "retry_with_changes", explanation: "Re-run with --format markdown or --format html." }
+        }
+      });
+      process.exit(1);
+    }
+    const body = { url, format };
+    if (args["wait-for"]) body.waitFor = Number(args["wait-for"]);
+    if (args["whole-page"]) body.onlyMainContent = false;
+    try {
+      const page = await apiPost("/api/research/fetch", body, { timeoutMs: TIMEOUT_MS });
+      const content = args.full ? page.content : page.content.slice(0, CONTENT_PREVIEW_CHARS);
+      writeResearchJson({
+        ok: true,
+        data: {
+          url: page.url,
+          final_url: page.finalUrl,
+          title: page.title,
+          content_chars: page.contentChars,
+          content_shown: content.length,
+          truncated: page.truncated,
+          provider: page.provider,
+          content
+        },
+        fields: FIELDS,
+        hints: fetchHints({
+          truncated: page.truncated,
+          contentChars: page.contentChars,
+          shownChars: content.length
+        })
+      });
+    } catch (err) {
+      handleResearchError(err, (code) => redditPageFix(url, code) ?? fetchFix(code));
+    }
+  }
+});
+export {
+  fetchCommand
+};
+//# sourceMappingURL=fetch-L2X4J6NL.js.map